include/atomic

// -*- C++ -*-
//===--------------------------- atomic -----------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef _LIBCPP_ATOMIC
#define _LIBCPP_ATOMIC

/*
    atomic synopsis

namespace std
{

// order and consistency

typedef enum memory_order
{
    memory_order_relaxed,
    memory_order_consume,  // load-consume
    memory_order_acquire,  // load-acquire
    memory_order_release,  // store-release
    memory_order_acq_rel,  // store-release load-acquire
    memory_order_seq_cst   // store-release load-acquire
} memory_order;

template <class T> T kill_dependency(T y);

// lock-free property

#define ATOMIC_CHAR_LOCK_FREE unspecified
#define ATOMIC_CHAR16_T_LOCK_FREE unspecified
#define ATOMIC_CHAR32_T_LOCK_FREE unspecified
#define ATOMIC_WCHAR_T_LOCK_FREE unspecified
#define ATOMIC_SHORT_LOCK_FREE unspecified
#define ATOMIC_INT_LOCK_FREE unspecified
#define ATOMIC_LONG_LOCK_FREE unspecified
#define ATOMIC_LLONG_LOCK_FREE unspecified
#define ATOMIC_ADDRESS_LOCK_FREE unspecified

// flag type and operations

typedef struct atomic_flag
{
    bool test_and_set(memory_order = memory_order_seq_cst) volatile;
    bool test_and_set(memory_order = memory_order_seq_cst);
    void clear(memory_order = memory_order_seq_cst) volatile;
    void clear(memory_order = memory_order_seq_cst);
    atomic_flag() = default;
    atomic_flag(const atomic_flag&) = delete;
    atomic_flag& operator=(const atomic_flag&) = delete;
    atomic_flag& operator=(const atomic_flag&) volatile = delete;
} atomic_flag;

bool atomic_flag_test_and_set(volatile atomic_flag*);
bool atomic_flag_test_and_set(atomic_flag*);
bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order);
bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order);
void atomic_flag_clear(volatile atomic_flag*);
void atomic_flag_clear(atomic_flag*);
void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order);
void atomic_flag_clear_explicit(atomic_flag*, memory_order);

#define ATOMIC_FLAG_INIT see below
#define ATOMIC_VAR_INIT(value) see below

// atomic_bool

typedef struct atomic_bool
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(bool, memory_order = memory_order_seq_cst) volatile;
    void store(bool, memory_order = memory_order_seq_cst);
    bool load(memory_order = memory_order_seq_cst) const volatile;
    bool load(memory_order = memory_order_seq_cst) const;
    operator bool() const volatile;
    operator bool() const;
    bool exchange(bool, memory_order = memory_order_seq_cst) volatile;
    bool exchange(bool, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(bool&, bool, memory_order,
                               memory_order) volatile;
    bool compare_exchange_weak(bool&, bool, memory_order, memory_order);
    bool compare_exchange_strong(bool&, bool, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(bool&, bool, memory_order, memory_order);
    bool compare_exchange_weak(bool&, bool,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(bool&, bool,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(bool&, bool,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(bool&, bool,
                                 memory_order = memory_order_seq_cst);
    atomic_bool() = default;
    constexpr atomic_bool(bool);
    atomic_bool(const atomic_bool&) = delete;
    atomic_bool& operator=(const atomic_bool&) = delete;
    atomic_bool& operator=(const atomic_bool&) volatile = delete;
    bool operator=(bool) volatile;
    bool operator=(bool);
} atomic_bool;

bool atomic_is_lock_free(const volatile atomic_bool*);
bool atomic_is_lock_free(const atomic_bool*);
void atomic_init(volatile atomic_bool*, bool);
void atomic_init(atomic_bool*, bool);
void atomic_store(volatile atomic_bool*, bool);
void atomic_store(atomic_bool*, bool);
void atomic_store_explicit(volatile atomic_bool*, bool, memory_order);
void atomic_store_explicit(atomic_bool*, bool, memory_order);
bool atomic_load(const volatile atomic_bool*);
bool atomic_load(const atomic_bool*);
bool atomic_load_explicit(const volatile atomic_bool*, memory_order);
bool atomic_load_explicit(const atomic_bool*, memory_order);
bool atomic_exchange(volatile atomic_bool*, bool);
bool atomic_exchange(atomic_bool*, bool);
bool atomic_exchange_explicit(volatile atomic_bool*, bool, memory_order);
bool atomic_exchange_explicit(atomic_bool*, bool, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_bool*, bool*, bool);
bool atomic_compare_exchange_weak(atomic_bool*, bool*, bool);
bool atomic_compare_exchange_strong(volatile atomic_bool*, bool*, bool);
bool atomic_compare_exchange_strong(atomic_bool*, bool*, bool);
bool atomic_compare_exchange_weak_explicit(volatile atomic_bool*, bool*, bool,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_bool*, bool*, bool,
                                           memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_bool*, bool*, bool,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_bool*, bool*, bool,
                                             memory_order, memory_order);

// atomic_char

typedef struct atomic_char
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(char, memory_order = memory_order_seq_cst) volatile;
    void store(char, memory_order = memory_order_seq_cst);
    char load(memory_order = memory_order_seq_cst) const volatile;
    char load(memory_order = memory_order_seq_cst) const;
    operator char() const volatile;
    operator char() const;
    char exchange(char, memory_order = memory_order_seq_cst) volatile;
    char exchange(char, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(char&, char, memory_order,
                               memory_order) volatile;
    bool compare_exchange_weak(char&, char, memory_order, memory_order);
    bool compare_exchange_strong(char&, char, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(char&, char, memory_order, memory_order);
    bool compare_exchange_weak(char&, char,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(char&, char,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(char&, char,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(char&, char,
                                 memory_order = memory_order_seq_cst);
    char fetch_add(char, memory_order = memory_order_seq_cst) volatile;
    char fetch_add(char, memory_order = memory_order_seq_cst);
    char fetch_sub(char, memory_order = memory_order_seq_cst) volatile;
    char fetch_sub(char, memory_order = memory_order_seq_cst);
    char fetch_and(char, memory_order = memory_order_seq_cst) volatile;
    char fetch_and(char, memory_order = memory_order_seq_cst);
    char fetch_or(char, memory_order = memory_order_seq_cst) volatile;
    char fetch_or(char, memory_order = memory_order_seq_cst);
    char fetch_xor(char, memory_order = memory_order_seq_cst) volatile;
    char fetch_xor(char, memory_order = memory_order_seq_cst);
    atomic_char() = default;
    constexpr atomic_char(char);
    atomic_char(const atomic_char&) = delete;
    atomic_char& operator=(const atomic_char&) = delete;
    atomic_char& operator=(const atomic_char&) volatile = delete;
    char operator=(char) volatile;
    char operator=(char);
    char operator++(int) volatile;
    char operator++(int);
    char operator--(int) volatile;
    char operator--(int);
    char operator++() volatile;
    char operator++();
    char operator--() volatile;
    char operator--();
    char operator+=(char) volatile;
    char operator+=(char);
    char operator-=(char) volatile;
    char operator-=(char);
    char operator&=(char) volatile;
    char operator&=(char);
    char operator|=(char) volatile;
    char operator|=(char);
    char operator^=(char) volatile;
    char operator^=(char);
} atomic_char;

bool atomic_is_lock_free(const volatile atomic_char*);
bool atomic_is_lock_free(const atomic_char*);
void atomic_init(volatile atomic_char*, char);
void atomic_init(atomic_char*, char);
void atomic_store(volatile atomic_char*, char);
void atomic_store(atomic_char*, char);
void atomic_store_explicit(volatile atomic_char*, char, memory_order);
void atomic_store_explicit(atomic_char*, char, memory_order);
char atomic_load(const volatile atomic_char*);
char atomic_load(const atomic_char*);
char atomic_load_explicit(const volatile atomic_char*, memory_order);
char atomic_load_explicit(const atomic_char*, memory_order);
char atomic_exchange(volatile atomic_char*, char);
char atomic_exchange(atomic_char*, char);
char atomic_exchange_explicit(volatile atomic_char*, char, memory_order);
char atomic_exchange_explicit(atomic_char*, char, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_char*, char*, char);
bool atomic_compare_exchange_weak(atomic_char*, char*, char);
bool atomic_compare_exchange_strong(volatile atomic_char*, char*, char);
bool atomic_compare_exchange_strong(atomic_char*, char*, char);
bool atomic_compare_exchange_weak_explicit(volatile atomic_char*, char*, char,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_char*, char*, char,
                                           memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_char*, char*, char,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_char*, char*, char,
                                             memory_order, memory_order);
char atomic_fetch_add(volatile atomic_char*, char);
char atomic_fetch_add(atomic_char*, char);
char atomic_fetch_add_explicit(volatile atomic_char*, char, memory_order);
char atomic_fetch_add_explicit(atomic_char*, char, memory_order);
char atomic_fetch_sub(volatile atomic_char*, char);
char atomic_fetch_sub(atomic_char*, char);
char atomic_fetch_sub_explicit(volatile atomic_char*, char, memory_order);
char atomic_fetch_sub_explicit(atomic_char*, char, memory_order);
char atomic_fetch_and(volatile atomic_char*, char);
char atomic_fetch_and(atomic_char*, char);
char atomic_fetch_and_explicit(volatile atomic_char*, char, memory_order);
char atomic_fetch_and_explicit(atomic_char*, char, memory_order);
char atomic_fetch_or(volatile atomic_char*, char);
char atomic_fetch_or(atomic_char*, char);
char atomic_fetch_or_explicit(volatile atomic_char*, char, memory_order);
char atomic_fetch_or_explicit(atomic_char*, char, memory_order);
char atomic_fetch_xor(volatile atomic_char*, char);
char atomic_fetch_xor(atomic_char*, char);
char atomic_fetch_xor_explicit(volatile atomic_char*, char, memory_order);
char atomic_fetch_xor_explicit(atomic_char*, char, memory_order);

// atomic_schar

typedef struct atomic_schar
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(signed char, memory_order = memory_order_seq_cst) volatile;
    void store(signed char, memory_order = memory_order_seq_cst);
    signed char load(memory_order = memory_order_seq_cst) const volatile;
    signed char load(memory_order = memory_order_seq_cst) const;
    operator signed char() const volatile;
    operator signed char() const;
    signed char exchange(signed char,
                         memory_order = memory_order_seq_cst) volatile;
    signed char exchange(signed char, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(signed char&, signed char, memory_order,
                               memory_order) volatile;
    bool compare_exchange_weak(signed char&, signed char, memory_order,
                               memory_order);
    bool compare_exchange_strong(signed char&, signed char, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(signed char&, signed char, memory_order,
                                 memory_order);
    bool compare_exchange_weak(signed char&, signed char,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(signed char&, signed char,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(signed char&, signed char,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(signed char&, signed char,
                                 memory_order = memory_order_seq_cst);
    signed char fetch_add(signed char,
                          memory_order = memory_order_seq_cst) volatile;
    signed char fetch_add(signed char, memory_order = memory_order_seq_cst);
    signed char fetch_sub(signed char,
                          memory_order = memory_order_seq_cst) volatile;
    signed char fetch_sub(signed char, memory_order = memory_order_seq_cst);
    signed char fetch_and(signed char,
                          memory_order = memory_order_seq_cst) volatile;
    signed char fetch_and(signed char, memory_order = memory_order_seq_cst);
    signed char fetch_or(signed char,
                         memory_order = memory_order_seq_cst) volatile;
    signed char fetch_or(signed char, memory_order = memory_order_seq_cst);
    signed char fetch_xor(signed char,
                          memory_order = memory_order_seq_cst) volatile;
    signed char fetch_xor(signed char, memory_order = memory_order_seq_cst);
    atomic_schar() = default;
    constexpr atomic_schar(signed char);
    atomic_schar(const atomic_schar&) = delete;
    atomic_schar& operator=(const atomic_schar&) = delete;
    atomic_schar& operator=(const atomic_schar&) volatile = delete;
    signed char operator=(signed char) volatile;
    signed char operator=(signed char);
    signed char operator++(int) volatile;
    signed char operator++(int);
    signed char operator--(int) volatile;
    signed char operator--(int);
    signed char operator++() volatile;
    signed char operator++();
    signed char operator--() volatile;
    signed char operator--();
    signed char operator+=(signed char) volatile;
    signed char operator+=(signed char);
    signed char operator-=(signed char) volatile;
    signed char operator-=(signed char);
    signed char operator&=(signed char) volatile;
    signed char operator&=(signed char);
    signed char operator|=(signed char) volatile;
    signed char operator|=(signed char);
    signed char operator^=(signed char) volatile;
    signed char operator^=(signed char);
} atomic_schar;

bool atomic_is_lock_free(const volatile atomic_schar*);
bool atomic_is_lock_free(const atomic_schar*);
void atomic_init(volatile atomic_schar*, signed char);
void atomic_init(atomic_schar*, signed char);
void atomic_store(volatile atomic_schar*, signed char);
void atomic_store(atomic_schar*, signed char);
void atomic_store_explicit(volatile atomic_schar*, signed char, memory_order);
void atomic_store_explicit(atomic_schar*, signed char, memory_order);
signed char atomic_load(const volatile atomic_schar*);
signed char atomic_load(const atomic_schar*);
signed char atomic_load_explicit(const volatile atomic_schar*, memory_order);
signed char atomic_load_explicit(const atomic_schar*, memory_order);
signed char atomic_exchange(volatile atomic_schar*, signed char);
signed char atomic_exchange(atomic_schar*, signed char);
signed char atomic_exchange_explicit(volatile atomic_schar*, signed char,
                                     memory_order);
signed char atomic_exchange_explicit(atomic_schar*, signed char, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_schar*, signed char*,
                                  signed char);
bool atomic_compare_exchange_weak(atomic_schar*, signed char*, signed char);
bool atomic_compare_exchange_strong(volatile atomic_schar*, signed char*,
                                    signed char);
bool atomic_compare_exchange_strong(atomic_schar*, signed char*, signed char);
bool atomic_compare_exchange_weak_explicit(volatile atomic_schar*, signed char*,
                                           signed char, memory_order,
                                           memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_schar*, signed char*,
                                           signed char, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_schar*,
                                             signed char*, signed char,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_schar*, signed char*,
                                             signed char, memory_order, memory_order);
signed char atomic_fetch_add(volatile atomic_schar*, signed char);
signed char atomic_fetch_add(atomic_schar*, signed char);
signed char atomic_fetch_add_explicit(volatile atomic_schar*, signed char,
                                      memory_order);
signed char atomic_fetch_add_explicit(atomic_schar*, signed char, memory_order);
signed char atomic_fetch_sub(volatile atomic_schar*, signed char);
signed char atomic_fetch_sub(atomic_schar*, signed char);
signed char atomic_fetch_sub_explicit(volatile atomic_schar*, signed char,
                                      memory_order);
signed char atomic_fetch_sub_explicit(atomic_schar*, signed char, memory_order);
signed char atomic_fetch_and(volatile atomic_schar*, signed char);
signed char atomic_fetch_and(atomic_schar*, signed char);
signed char atomic_fetch_and_explicit(volatile atomic_schar*, signed char,
                                      memory_order);
signed char atomic_fetch_and_explicit(atomic_schar*, signed char, memory_order);
signed char atomic_fetch_or(volatile atomic_schar*, signed char);
signed char atomic_fetch_or(atomic_schar*, signed char);
signed char atomic_fetch_or_explicit(volatile atomic_schar*, signed char,
                                     memory_order);
signed char atomic_fetch_or_explicit(atomic_schar*, signed char, memory_order);
signed char atomic_fetch_xor(volatile atomic_schar*, signed char);
signed char atomic_fetch_xor(atomic_schar*, signed char);
signed char atomic_fetch_xor_explicit(volatile atomic_schar*, signed char,
                                      memory_order);
signed char atomic_fetch_xor_explicit(atomic_schar*, signed char, memory_order);

// atomic_uchar

typedef struct atomic_uchar
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(unsigned char, memory_order = memory_order_seq_cst) volatile;
    void store(unsigned char, memory_order = memory_order_seq_cst);
    unsigned char load(memory_order = memory_order_seq_cst) const volatile;
    unsigned char load(memory_order = memory_order_seq_cst) const;
    operator unsigned char() const volatile;
    operator unsigned char() const;
    unsigned char exchange(unsigned char,
                           memory_order = memory_order_seq_cst) volatile;
    unsigned char exchange(unsigned char, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(unsigned char&, unsigned char, memory_order,
                               memory_order) volatile;
    bool compare_exchange_weak(unsigned char&, unsigned char, memory_order,
                               memory_order);
    bool compare_exchange_strong(unsigned char&, unsigned char, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(unsigned char&, unsigned char, memory_order,
                                 memory_order);
    bool compare_exchange_weak(unsigned char&, unsigned char,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(unsigned char&, unsigned char,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(unsigned char&, unsigned char,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(unsigned char&, unsigned char,
                                 memory_order = memory_order_seq_cst);
    unsigned char fetch_add(unsigned char,
                            memory_order = memory_order_seq_cst) volatile;
    unsigned char fetch_add(unsigned char, memory_order = memory_order_seq_cst);
    unsigned char fetch_sub(unsigned char,
                            memory_order = memory_order_seq_cst) volatile;
    unsigned char fetch_sub(unsigned char, memory_order = memory_order_seq_cst);
    unsigned char fetch_and(unsigned char,
                            memory_order = memory_order_seq_cst) volatile;
    unsigned char fetch_and(unsigned char, memory_order = memory_order_seq_cst);
    unsigned char fetch_or(unsigned char,
                           memory_order = memory_order_seq_cst) volatile;
    unsigned char fetch_or(unsigned char, memory_order = memory_order_seq_cst);
    unsigned char fetch_xor(unsigned char,
                            memory_order = memory_order_seq_cst) volatile;
    unsigned char fetch_xor(unsigned char, memory_order = memory_order_seq_cst);
    atomic_uchar() = default;
    constexpr atomic_uchar(unsigned char);
    atomic_uchar(const atomic_uchar&) = delete;
    atomic_uchar& operator=(const atomic_uchar&) = delete;
    atomic_uchar& operator=(const atomic_uchar&) volatile = delete;
    unsigned char operator=(unsigned char) volatile;
    unsigned char operator=(unsigned char);
    unsigned char operator++(int) volatile;
    unsigned char operator++(int);
    unsigned char operator--(int) volatile;
    unsigned char operator--(int);
    unsigned char operator++() volatile;
    unsigned char operator++();
    unsigned char operator--() volatile;
    unsigned char operator--();
    unsigned char operator+=(unsigned char) volatile;
    unsigned char operator+=(unsigned char);
    unsigned char operator-=(unsigned char) volatile;
    unsigned char operator-=(unsigned char);
    unsigned char operator&=(unsigned char) volatile;
    unsigned char operator&=(unsigned char);
    unsigned char operator|=(unsigned char) volatile;
    unsigned char operator|=(unsigned char);
    unsigned char operator^=(unsigned char) volatile;
    unsigned char operator^=(unsigned char);
} atomic_uchar;

bool atomic_is_lock_free(const volatile atomic_uchar*);
bool atomic_is_lock_free(const atomic_uchar*);
void atomic_init(volatile atomic_uchar*, unsigned char);
void atomic_init(atomic_uchar*, unsigned char);
void atomic_store(volatile atomic_uchar*, unsigned char);
void atomic_store(atomic_uchar*, unsigned char);
void atomic_store_explicit(volatile atomic_uchar*, unsigned char, memory_order);
void atomic_store_explicit(atomic_uchar*, unsigned char, memory_order);
unsigned char atomic_load(const volatile atomic_uchar*);
unsigned char atomic_load(const atomic_uchar*);
unsigned char atomic_load_explicit(const volatile atomic_uchar*, memory_order);
unsigned char atomic_load_explicit(const atomic_uchar*, memory_order);
unsigned char atomic_exchange(volatile atomic_uchar*, unsigned char);
unsigned char atomic_exchange(atomic_uchar*, unsigned char);
unsigned char atomic_exchange_explicit(volatile atomic_uchar*, unsigned char,
                                       memory_order);
unsigned char atomic_exchange_explicit(atomic_uchar*, unsigned char,
                                       memory_order);
bool atomic_compare_exchange_weak(volatile atomic_uchar*, unsigned char*,
                                  unsigned char);
bool atomic_compare_exchange_weak(atomic_uchar*, unsigned char*, unsigned char);
bool atomic_compare_exchange_strong(volatile atomic_uchar*, unsigned char*,
                                    unsigned char);
bool atomic_compare_exchange_strong(atomic_uchar*, unsigned char*,
                                    unsigned char);
bool atomic_compare_exchange_weak_explicit(volatile atomic_uchar*,
                                           unsigned char*, unsigned char,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_uchar*, unsigned char*,
                                           unsigned char, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_uchar*,
                                             unsigned char*, unsigned char,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_uchar*, unsigned char*,
                                             unsigned char, memory_order,
                                             memory_order);
unsigned char atomic_fetch_add(volatile atomic_uchar*, unsigned char);
unsigned char atomic_fetch_add(atomic_uchar*, unsigned char);
unsigned char atomic_fetch_add_explicit(volatile atomic_uchar*, unsigned char,
                                        memory_order);
unsigned char atomic_fetch_add_explicit(atomic_uchar*, unsigned char,
                                        memory_order);
unsigned char atomic_fetch_sub(volatile atomic_uchar*, unsigned char);
unsigned char atomic_fetch_sub(atomic_uchar*, unsigned char);
unsigned char atomic_fetch_sub_explicit(volatile atomic_uchar*, unsigned char,
                                        memory_order);
unsigned char atomic_fetch_sub_explicit(atomic_uchar*, unsigned char,
                                        memory_order);
unsigned char atomic_fetch_and(volatile atomic_uchar*, unsigned char);
unsigned char atomic_fetch_and(atomic_uchar*, unsigned char);
unsigned char atomic_fetch_and_explicit(volatile atomic_uchar*, unsigned char,
                                        memory_order);
unsigned char atomic_fetch_and_explicit(atomic_uchar*, unsigned char,
                                        memory_order);
unsigned char atomic_fetch_or(volatile atomic_uchar*, unsigned char);
unsigned char atomic_fetch_or(atomic_uchar*, unsigned char);
unsigned char atomic_fetch_or_explicit(volatile atomic_uchar*, unsigned char,
                                       memory_order);
unsigned char atomic_fetch_or_explicit(atomic_uchar*, unsigned char,
                                       memory_order);
unsigned char atomic_fetch_xor(volatile atomic_uchar*, unsigned char);
unsigned char atomic_fetch_xor(atomic_uchar*, unsigned char);
unsigned char atomic_fetch_xor_explicit(volatile atomic_uchar*, unsigned char,
                                        memory_order);
unsigned char atomic_fetch_xor_explicit(atomic_uchar*, unsigned char,
                                        memory_order);

// atomic_short

typedef struct atomic_short
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(short, memory_order = memory_order_seq_cst) volatile;
    void store(short, memory_order = memory_order_seq_cst);
    short load(memory_order = memory_order_seq_cst) const volatile;
    short load(memory_order = memory_order_seq_cst) const;
    operator short() const volatile;
    operator short() const;
    short exchange(short, memory_order = memory_order_seq_cst) volatile;
    short exchange(short, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(short&, short, memory_order,
                               memory_order) volatile;
    bool compare_exchange_weak(short&, short, memory_order, memory_order);
    bool compare_exchange_strong(short&, short, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(short&, short, memory_order, memory_order);
    bool compare_exchange_weak(short&, short,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(short&, short,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(short&, short,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(short&, short,
                                 memory_order = memory_order_seq_cst);
    short fetch_add(short, memory_order = memory_order_seq_cst) volatile;
    short fetch_add(short, memory_order = memory_order_seq_cst);
    short fetch_sub(short, memory_order = memory_order_seq_cst) volatile;
    short fetch_sub(short, memory_order = memory_order_seq_cst);
    short fetch_and(short, memory_order = memory_order_seq_cst) volatile;
    short fetch_and(short, memory_order = memory_order_seq_cst);
    short fetch_or(short, memory_order = memory_order_seq_cst) volatile;
    short fetch_or(short, memory_order = memory_order_seq_cst);
    short fetch_xor(short, memory_order = memory_order_seq_cst) volatile;
    short fetch_xor(short, memory_order = memory_order_seq_cst);
    atomic_short() = default;
    constexpr atomic_short(short);
    atomic_short(const atomic_short&) = delete;
    atomic_short& operator=(const atomic_short&) = delete;
    atomic_short& operator=(const atomic_short&) volatile = delete;
    short operator=(short) volatile;
    short operator=(short);
    short operator++(int) volatile;
    short operator++(int);
    short operator--(int) volatile;
    short operator--(int);
    short operator++() volatile;
    short operator++();
    short operator--() volatile;
    short operator--();
    short operator+=(short) volatile;
    short operator+=(short);
    short operator-=(short) volatile;
    short operator-=(short);
    short operator&=(short) volatile;
    short operator&=(short);
    short operator|=(short) volatile;
    short operator|=(short);
    short operator^=(short) volatile;
    short operator^=(short);
} atomic_short;

bool atomic_is_lock_free(const volatile atomic_short*);
bool atomic_is_lock_free(const atomic_short*);
void atomic_init(volatile atomic_short*, short);
void atomic_init(atomic_short*, short);
void atomic_store(volatile atomic_short*, short);
void atomic_store(atomic_short*, short);
void atomic_store_explicit(volatile atomic_short*, short, memory_order);
void atomic_store_explicit(atomic_short*, short, memory_order);
short atomic_load(const volatile atomic_short*);
short atomic_load(const atomic_short*);
short atomic_load_explicit(const volatile atomic_short*, memory_order);
short atomic_load_explicit(const atomic_short*, memory_order);
short atomic_exchange(volatile atomic_short*, short);
short atomic_exchange(atomic_short*, short);
short atomic_exchange_explicit(volatile atomic_short*, short, memory_order);
short atomic_exchange_explicit(atomic_short*, short, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_short*, short*, short);
bool atomic_compare_exchange_weak(atomic_short*, short*, short);
bool atomic_compare_exchange_strong(volatile atomic_short*, short*, short);
bool atomic_compare_exchange_strong(atomic_short*, short*, short);
bool atomic_compare_exchange_weak_explicit(volatile atomic_short*, short*,
                                           short, memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_short*, short*, short,
                                           memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_short*, short*,
                                             short, memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_short*, short*, short,
                                             memory_order, memory_order);
short atomic_fetch_add(volatile atomic_short*, short);
short atomic_fetch_add(atomic_short*, short);
short atomic_fetch_add_explicit(volatile atomic_short*, short, memory_order);
short atomic_fetch_add_explicit(atomic_short*, short, memory_order);
short atomic_fetch_sub(volatile atomic_short*, short);
short atomic_fetch_sub(atomic_short*, short);
short atomic_fetch_sub_explicit(volatile atomic_short*, short, memory_order);
short atomic_fetch_sub_explicit(atomic_short*, short, memory_order);
short atomic_fetch_and(volatile atomic_short*, short);
short atomic_fetch_and(atomic_short*, short);
short atomic_fetch_and_explicit(volatile atomic_short*, short, memory_order);
short atomic_fetch_and_explicit(atomic_short*, short, memory_order);
short atomic_fetch_or(volatile atomic_short*, short);
short atomic_fetch_or(atomic_short*, short);
short atomic_fetch_or_explicit(volatile atomic_short*, short, memory_order);
short atomic_fetch_or_explicit(atomic_short*, short, memory_order);
short atomic_fetch_xor(volatile atomic_short*, short);
short atomic_fetch_xor(atomic_short*, short);
short atomic_fetch_xor_explicit(volatile atomic_short*, short, memory_order);
short atomic_fetch_xor_explicit(atomic_short*, short, memory_order);

// atomic_ushort

typedef struct atomic_ushort
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(unsigned short, memory_order = memory_order_seq_cst) volatile;
    void store(unsigned short, memory_order = memory_order_seq_cst);
    unsigned short load(memory_order = memory_order_seq_cst) const volatile;
    unsigned short load(memory_order = memory_order_seq_cst) const;
    operator unsigned short() const volatile;
    operator unsigned short() const;
    unsigned short exchange(unsigned short,
                            memory_order = memory_order_seq_cst) volatile;
    unsigned short exchange(unsigned short,
                            memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(unsigned short&, unsigned short, memory_order,
                               memory_order) volatile;
    bool compare_exchange_weak(unsigned short&, unsigned short, memory_order,
                               memory_order);
    bool compare_exchange_strong(unsigned short&, unsigned short, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(unsigned short&, unsigned short, memory_order,
                                 memory_order);
    bool compare_exchange_weak(unsigned short&, unsigned short,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(unsigned short&, unsigned short,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(unsigned short&, unsigned short,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(unsigned short&, unsigned short,
                                 memory_order = memory_order_seq_cst);
    unsigned short fetch_add(unsigned short,
                             memory_order = memory_order_seq_cst) volatile;
    unsigned short fetch_add(unsigned short,
                             memory_order = memory_order_seq_cst);
    unsigned short fetch_sub(unsigned short,
                             memory_order = memory_order_seq_cst) volatile;
    unsigned short fetch_sub(unsigned short,
                             memory_order = memory_order_seq_cst);
    unsigned short fetch_and(unsigned short,
                             memory_order = memory_order_seq_cst) volatile;
    unsigned short fetch_and(unsigned short,
                             memory_order = memory_order_seq_cst);
    unsigned short fetch_or(unsigned short,
                            memory_order = memory_order_seq_cst) volatile;
    unsigned short fetch_or(unsigned short,
                            memory_order = memory_order_seq_cst);
    unsigned short fetch_xor(unsigned short,
                             memory_order = memory_order_seq_cst) volatile;
    unsigned short fetch_xor(unsigned short,
                             memory_order = memory_order_seq_cst);
    atomic_ushort() = default;
    constexpr atomic_ushort(unsigned short);
    atomic_ushort(const atomic_ushort&) = delete;
    atomic_ushort& operator=(const atomic_ushort&) = delete;
    atomic_ushort& operator=(const atomic_ushort&) volatile = delete;
    unsigned short operator=(unsigned short) volatile;
    unsigned short operator=(unsigned short);
    unsigned short operator++(int) volatile;
    unsigned short operator++(int);
    unsigned short operator--(int) volatile;
    unsigned short operator--(int);
    unsigned short operator++() volatile;
    unsigned short operator++();
    unsigned short operator--() volatile;
    unsigned short operator--();
    unsigned short operator+=(unsigned short) volatile;
    unsigned short operator+=(unsigned short);
    unsigned short operator-=(unsigned short) volatile;
    unsigned short operator-=(unsigned short);
    unsigned short operator&=(unsigned short) volatile;
    unsigned short operator&=(unsigned short);
    unsigned short operator|=(unsigned short) volatile;
    unsigned short operator|=(unsigned short);
    unsigned short operator^=(unsigned short) volatile;
    unsigned short operator^=(unsigned short);
} atomic_ushort;

bool atomic_is_lock_free(const volatile atomic_ushort*);
bool atomic_is_lock_free(const atomic_ushort*);
void atomic_init(volatile atomic_ushort*, unsigned short);
void atomic_init(atomic_ushort*, unsigned short);
void atomic_store(volatile atomic_ushort*, unsigned short);
void atomic_store(atomic_ushort*, unsigned short);
void atomic_store_explicit(volatile atomic_ushort*, unsigned short,
                           memory_order);
void atomic_store_explicit(atomic_ushort*, unsigned short, memory_order);
unsigned short atomic_load(const volatile atomic_ushort*);
unsigned short atomic_load(const atomic_ushort*);
unsigned short atomic_load_explicit(const volatile atomic_ushort*,
                                    memory_order);
unsigned short atomic_load_explicit(const atomic_ushort*, memory_order);
unsigned short atomic_exchange(volatile atomic_ushort*, unsigned short);
unsigned short atomic_exchange(atomic_ushort*, unsigned short);
unsigned short atomic_exchange_explicit(volatile atomic_ushort*, unsigned short,
                                        memory_order);
unsigned short atomic_exchange_explicit(atomic_ushort*, unsigned short,
                                        memory_order);
bool atomic_compare_exchange_weak(volatile atomic_ushort*, unsigned short*,
                                  unsigned short);
bool atomic_compare_exchange_weak(atomic_ushort*, unsigned short*,
                                  unsigned short);
bool atomic_compare_exchange_strong(volatile atomic_ushort*, unsigned short*,
                                    unsigned short);
bool atomic_compare_exchange_strong(atomic_ushort*, unsigned short*,
                                    unsigned short);
bool atomic_compare_exchange_weak_explicit(volatile atomic_ushort*,
                                           unsigned short*, unsigned short,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_ushort*, unsigned short*,
                                           unsigned short, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_ushort*,
                                             unsigned short*, unsigned short,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_ushort*, unsigned short*,
                                             unsigned short, memory_order,
                                             memory_order);
unsigned short atomic_fetch_add(volatile atomic_ushort*, unsigned short);
unsigned short atomic_fetch_add(atomic_ushort*, unsigned short);
unsigned short atomic_fetch_add_explicit(volatile atomic_ushort*,
                                         unsigned short, memory_order);
unsigned short atomic_fetch_add_explicit(atomic_ushort*, unsigned short,
                                         memory_order);
unsigned short atomic_fetch_sub(volatile atomic_ushort*, unsigned short);
unsigned short atomic_fetch_sub(atomic_ushort*, unsigned short);
unsigned short atomic_fetch_sub_explicit(volatile atomic_ushort*,
                                         unsigned short, memory_order);
unsigned short atomic_fetch_sub_explicit(atomic_ushort*, unsigned short,
                                         memory_order);
unsigned short atomic_fetch_and(volatile atomic_ushort*, unsigned short);
unsigned short atomic_fetch_and(atomic_ushort*, unsigned short);
unsigned short atomic_fetch_and_explicit(volatile atomic_ushort*,
                                         unsigned short, memory_order);
unsigned short atomic_fetch_and_explicit(atomic_ushort*, unsigned short,
                                         memory_order);
unsigned short atomic_fetch_or(volatile atomic_ushort*, unsigned short);
unsigned short atomic_fetch_or(atomic_ushort*, unsigned short);
unsigned short atomic_fetch_or_explicit(volatile atomic_ushort*, unsigned short,
                                        memory_order);
unsigned short atomic_fetch_or_explicit(atomic_ushort*, unsigned short,
                                        memory_order);
unsigned short atomic_fetch_xor(volatile atomic_ushort*, unsigned short);
unsigned short atomic_fetch_xor(atomic_ushort*, unsigned short);
unsigned short atomic_fetch_xor_explicit(volatile atomic_ushort*,
                                         unsigned short, memory_order);
unsigned short atomic_fetch_xor_explicit(atomic_ushort*, unsigned short,
                                         memory_order);

// atomic_int

typedef struct atomic_int
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(int, memory_order = memory_order_seq_cst) volatile;
    void store(int, memory_order = memory_order_seq_cst);
    int load(memory_order = memory_order_seq_cst) const volatile;
    int load(memory_order = memory_order_seq_cst) const;
    operator int() const volatile;
    operator int() const;
    int exchange(int, memory_order = memory_order_seq_cst) volatile;
    int exchange(int, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(int&, int, memory_order, memory_order) volatile;
    bool compare_exchange_weak(int&, int, memory_order, memory_order);
    bool compare_exchange_strong(int&, int, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(int&, int, memory_order, memory_order);
    bool compare_exchange_weak(int&, int,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(int&, int, memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(int&, int,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(int&, int,
                                 memory_order = memory_order_seq_cst);
    int fetch_add(int, memory_order = memory_order_seq_cst) volatile;
    int fetch_add(int, memory_order = memory_order_seq_cst);
    int fetch_sub(int, memory_order = memory_order_seq_cst) volatile;
    int fetch_sub(int, memory_order = memory_order_seq_cst);
    int fetch_and(int, memory_order = memory_order_seq_cst) volatile;
    int fetch_and(int, memory_order = memory_order_seq_cst);
    int fetch_or(int, memory_order = memory_order_seq_cst) volatile;
    int fetch_or(int, memory_order = memory_order_seq_cst);
    int fetch_xor(int, memory_order = memory_order_seq_cst) volatile;
    int fetch_xor(int, memory_order = memory_order_seq_cst);
    atomic_int() = default;
    constexpr atomic_int(int);
    atomic_int(const atomic_int&) = delete;
    atomic_int& operator=(const atomic_int&) = delete;
    atomic_int& operator=(const atomic_int&) volatile = delete;
    int operator=(int) volatile;
    int operator=(int);
    int operator++(int) volatile;
    int operator++(int);
    int operator--(int) volatile;
    int operator--(int);
    int operator++() volatile;
    int operator++();
    int operator--() volatile;
    int operator--();
    int operator+=(int) volatile;
    int operator+=(int);
    int operator-=(int) volatile;
    int operator-=(int);
    int operator&=(int) volatile;
    int operator&=(int);
    int operator|=(int) volatile;
    int operator|=(int);
    int operator^=(int) volatile;
    int operator^=(int);
} atomic_int;

bool atomic_is_lock_free(const volatile atomic_int*);
bool atomic_is_lock_free(const atomic_int*);
void atomic_init(volatile atomic_int*, int);
void atomic_init(atomic_int*, int);
void atomic_store(volatile atomic_int*, int);
void atomic_store(atomic_int*, int);
void atomic_store_explicit(volatile atomic_int*, int, memory_order);
void atomic_store_explicit(atomic_int*, int, memory_order);
int atomic_load(const volatile atomic_int*);
int atomic_load(const atomic_int*);
int atomic_load_explicit(const volatile atomic_int*, memory_order);
int atomic_load_explicit(const atomic_int*, memory_order);
int atomic_exchange(volatile atomic_int*, int);
int atomic_exchange(atomic_int*, int);
int atomic_exchange_explicit(volatile atomic_int*, int, memory_order);
int atomic_exchange_explicit(atomic_int*, int, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_int*, int*, int);
bool atomic_compare_exchange_weak(atomic_int*, int*, int);
bool atomic_compare_exchange_strong(volatile atomic_int*, int*, int);
bool atomic_compare_exchange_strong(atomic_int*, int*, int);
bool atomic_compare_exchange_weak_explicit(volatile atomic_int*, int*, int,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_int*, int*, int, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_int*, int*, int,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_int*, int*, int,
                                             memory_order, memory_order);
int atomic_fetch_add(volatile atomic_int*, int);
int atomic_fetch_add(atomic_int*, int);
int atomic_fetch_add_explicit(volatile atomic_int*, int, memory_order);
int atomic_fetch_add_explicit(atomic_int*, int, memory_order);
int atomic_fetch_sub(volatile atomic_int*, int);
int atomic_fetch_sub(atomic_int*, int);
int atomic_fetch_sub_explicit(volatile atomic_int*, int, memory_order);
int atomic_fetch_sub_explicit(atomic_int*, int, memory_order);
int atomic_fetch_and(volatile atomic_int*, int);
int atomic_fetch_and(atomic_int*, int);
int atomic_fetch_and_explicit(volatile atomic_int*, int, memory_order);
int atomic_fetch_and_explicit(atomic_int*, int, memory_order);
int atomic_fetch_or(volatile atomic_int*, int);
int atomic_fetch_or(atomic_int*, int);
int atomic_fetch_or_explicit(volatile atomic_int*, int, memory_order);
int atomic_fetch_or_explicit(atomic_int*, int, memory_order);
int atomic_fetch_xor(volatile atomic_int*, int);
int atomic_fetch_xor(atomic_int*, int);
int atomic_fetch_xor_explicit(volatile atomic_int*, int, memory_order);
int atomic_fetch_xor_explicit(atomic_int*, int, memory_order);

// atomic_uint

typedef struct atomic_uint
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(unsigned int, memory_order = memory_order_seq_cst) volatile;
    void store(unsigned int, memory_order = memory_order_seq_cst);
    unsigned int load(memory_order = memory_order_seq_cst) const volatile;
    unsigned int load(memory_order = memory_order_seq_cst) const;
    operator unsigned int() const volatile;
    operator unsigned int() const;
    unsigned int exchange(unsigned int,
                          memory_order = memory_order_seq_cst) volatile;
    unsigned int exchange(unsigned int, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(unsigned int&, unsigned int, memory_order,
                               memory_order) volatile;
    bool compare_exchange_weak(unsigned int&, unsigned int, memory_order,
                               memory_order);
    bool compare_exchange_strong(unsigned int&, unsigned int, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(unsigned int&, unsigned int, memory_order,
                                 memory_order);
    bool compare_exchange_weak(unsigned int&, unsigned int,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(unsigned int&, unsigned int,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(unsigned int&, unsigned int,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(unsigned int&, unsigned int,
                                 memory_order = memory_order_seq_cst);
    unsigned int fetch_add(unsigned int,
                           memory_order = memory_order_seq_cst) volatile;
    unsigned int fetch_add(unsigned int, memory_order = memory_order_seq_cst);
    unsigned int fetch_sub(unsigned int,
                           memory_order = memory_order_seq_cst) volatile;
    unsigned int fetch_sub(unsigned int, memory_order = memory_order_seq_cst);
    unsigned int fetch_and(unsigned int,
                           memory_order = memory_order_seq_cst) volatile;
    unsigned int fetch_and(unsigned int, memory_order = memory_order_seq_cst);
    unsigned int fetch_or(unsigned int,
                          memory_order = memory_order_seq_cst) volatile;
    unsigned int fetch_or(unsigned int, memory_order = memory_order_seq_cst);
    unsigned int fetch_xor(unsigned int,
                           memory_order = memory_order_seq_cst) volatile;
    unsigned int fetch_xor(unsigned int, memory_order = memory_order_seq_cst);
    atomic_uint() = default;
    constexpr atomic_uint(unsigned int);
    atomic_uint(const atomic_uint&) = delete;
    atomic_uint& operator=(const atomic_uint&) = delete;
    atomic_uint& operator=(const atomic_uint&) volatile = delete;
    unsigned int operator=(unsigned int) volatile;
    unsigned int operator=(unsigned int);
    unsigned int operator++(int) volatile;
    unsigned int operator++(int);
    unsigned int operator--(int) volatile;
    unsigned int operator--(int);
    unsigned int operator++() volatile;
    unsigned int operator++();
    unsigned int operator--() volatile;
    unsigned int operator--();
    unsigned int operator+=(unsigned int) volatile;
    unsigned int operator+=(unsigned int);
    unsigned int operator-=(unsigned int) volatile;
    unsigned int operator-=(unsigned int);
    unsigned int operator&=(unsigned int) volatile;
    unsigned int operator&=(unsigned int);
    unsigned int operator|=(unsigned int) volatile;
    unsigned int operator|=(unsigned int);
    unsigned int operator^=(unsigned int) volatile;
    unsigned int operator^=(unsigned int);
} atomic_uint;

bool atomic_is_lock_free(const volatile atomic_uint*);
bool atomic_is_lock_free(const atomic_uint*);
void atomic_init(volatile atomic_uint*, unsigned int);
void atomic_init(atomic_uint*, unsigned int);
void atomic_store(volatile atomic_uint*, unsigned int);
void atomic_store(atomic_uint*, unsigned int);
void atomic_store_explicit(volatile atomic_uint*, unsigned int, memory_order);
void atomic_store_explicit(atomic_uint*, unsigned int, memory_order);
unsigned int atomic_load(const volatile atomic_uint*);
unsigned int atomic_load(const atomic_uint*);
unsigned int atomic_load_explicit(const volatile atomic_uint*, memory_order);
unsigned int atomic_load_explicit(const atomic_uint*, memory_order);
unsigned int atomic_exchange(volatile atomic_uint*, unsigned int);
unsigned int atomic_exchange(atomic_uint*, unsigned int);
unsigned int atomic_exchange_explicit(volatile atomic_uint*, unsigned int,
                                      memory_order);
unsigned int atomic_exchange_explicit(atomic_uint*, unsigned int, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_uint*, unsigned int*,
                                  unsigned int);
bool atomic_compare_exchange_weak(atomic_uint*, unsigned int*, unsigned int);
bool atomic_compare_exchange_strong(volatile atomic_uint*, unsigned int*,
                                    unsigned int);
bool atomic_compare_exchange_strong(atomic_uint*, unsigned int*, unsigned int);
bool atomic_compare_exchange_weak_explicit(volatile atomic_uint*, unsigned int*,
                                           unsigned int, memory_order,
                                           memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_uint*, unsigned int*,
                                           unsigned int, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_uint*,
                                             unsigned int*, unsigned int,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_uint*, unsigned int*,
                                             unsigned int, memory_order, 
                                             memory_order);
unsigned int atomic_fetch_add(volatile atomic_uint*, unsigned int);
unsigned int atomic_fetch_add(atomic_uint*, unsigned int);
unsigned int atomic_fetch_add_explicit(volatile atomic_uint*, unsigned int,
                                       memory_order);
unsigned int atomic_fetch_add_explicit(atomic_uint*, unsigned int,
                                       memory_order);
unsigned int atomic_fetch_sub(volatile atomic_uint*, unsigned int);
unsigned int atomic_fetch_sub(atomic_uint*, unsigned int);
unsigned int atomic_fetch_sub_explicit(volatile atomic_uint*, unsigned int,
                                       memory_order);
unsigned int atomic_fetch_sub_explicit(atomic_uint*, unsigned int,
                                       memory_order);
unsigned int atomic_fetch_and(volatile atomic_uint*, unsigned int);
unsigned int atomic_fetch_and(atomic_uint*, unsigned int);
unsigned int atomic_fetch_and_explicit(volatile atomic_uint*, unsigned int,
                                       memory_order);
unsigned int atomic_fetch_and_explicit(atomic_uint*, unsigned int,
                                       memory_order);
unsigned int atomic_fetch_or(volatile atomic_uint*, unsigned int);
unsigned int atomic_fetch_or(atomic_uint*, unsigned int);
unsigned int atomic_fetch_or_explicit(volatile atomic_uint*, unsigned int,
                                      memory_order);
unsigned int atomic_fetch_or_explicit(atomic_uint*, unsigned int, memory_order);
unsigned int atomic_fetch_xor(volatile atomic_uint*, unsigned int);
unsigned int atomic_fetch_xor(atomic_uint*, unsigned int);
unsigned int atomic_fetch_xor_explicit(volatile atomic_uint*, unsigned int,
                                       memory_order);
unsigned int atomic_fetch_xor_explicit(atomic_uint*, unsigned int,
                                       memory_order);

// atomic_long

typedef struct atomic_long
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(long, memory_order = memory_order_seq_cst) volatile;
    void store(long, memory_order = memory_order_seq_cst);
    long load(memory_order = memory_order_seq_cst) const volatile;
    long load(memory_order = memory_order_seq_cst) const;
    operator long() const volatile;
    operator long() const;
    long exchange(long, memory_order = memory_order_seq_cst) volatile;
    long exchange(long, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(long&, long, memory_order,
                               memory_order) volatile;
    bool compare_exchange_weak(long&, long, memory_order, memory_order);
    bool compare_exchange_strong(long&, long, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(long&, long, memory_order, memory_order);
    bool compare_exchange_weak(long&, long,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(long&, long,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(long&, long,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(long&, long,
                                 memory_order = memory_order_seq_cst);
    long fetch_add(long, memory_order = memory_order_seq_cst) volatile;
    long fetch_add(long, memory_order = memory_order_seq_cst);
    long fetch_sub(long, memory_order = memory_order_seq_cst) volatile;
    long fetch_sub(long, memory_order = memory_order_seq_cst);
    long fetch_and(long, memory_order = memory_order_seq_cst) volatile;
    long fetch_and(long, memory_order = memory_order_seq_cst);
    long fetch_or(long, memory_order = memory_order_seq_cst) volatile;
    long fetch_or(long, memory_order = memory_order_seq_cst);
    long fetch_xor(long, memory_order = memory_order_seq_cst) volatile;
    long fetch_xor(long, memory_order = memory_order_seq_cst);
    atomic_long() = default;
    constexpr atomic_long(long);
    atomic_long(const atomic_long&) = delete;
    atomic_long& operator=(const atomic_long&) = delete;
    atomic_long& operator=(const atomic_long&) volatile = delete;
    long operator=(long) volatile;
    long operator=(long);
    long operator++(int) volatile;
    long operator++(int);
    long operator--(int) volatile;
    long operator--(int);
    long operator++() volatile;
    long operator++();
    long operator--() volatile;
    long operator--();
    long operator+=(long) volatile;
    long operator+=(long);
    long operator-=(long) volatile;
    long operator-=(long);
    long operator&=(long) volatile;
    long operator&=(long);
    long operator|=(long) volatile;
    long operator|=(long);
    long operator^=(long) volatile;
    long operator^=(long);
} atomic_long;

bool atomic_is_lock_free(const volatile atomic_long*);
bool atomic_is_lock_free(const atomic_long*);
void atomic_init(volatile atomic_long*, long);
void atomic_init(atomic_long*, long);
void atomic_store(volatile atomic_long*, long);
void atomic_store(atomic_long*, long);
void atomic_store_explicit(volatile atomic_long*, long, memory_order);
void atomic_store_explicit(atomic_long*, long, memory_order);
long atomic_load(const volatile atomic_long*);
long atomic_load(const atomic_long*);
long atomic_load_explicit(const volatile atomic_long*, memory_order);
long atomic_load_explicit(const atomic_long*, memory_order);
long atomic_exchange(volatile atomic_long*, long);
long atomic_exchange(atomic_long*, long);
long atomic_exchange_explicit(volatile atomic_long*, long, memory_order);
long atomic_exchange_explicit(atomic_long*, long, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_long*, long*, long);
bool atomic_compare_exchange_weak(atomic_long*, long*, long);
bool atomic_compare_exchange_strong(volatile atomic_long*, long*, long);
bool atomic_compare_exchange_strong(atomic_long*, long*, long);
bool atomic_compare_exchange_weak_explicit(volatile atomic_long*, long*, long,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_long*, long*, long,
                                           memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_long*, long*, long,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_long*, long*, long,
                                             memory_order, memory_order);
long atomic_fetch_add(volatile atomic_long*, long);
long atomic_fetch_add(atomic_long*, long);
long atomic_fetch_add_explicit(volatile atomic_long*, long, memory_order);
long atomic_fetch_add_explicit(atomic_long*, long, memory_order);
long atomic_fetch_sub(volatile atomic_long*, long);
long atomic_fetch_sub(atomic_long*, long);
long atomic_fetch_sub_explicit(volatile atomic_long*, long, memory_order);
long atomic_fetch_sub_explicit(atomic_long*, long, memory_order);
long atomic_fetch_and(volatile atomic_long*, long);
long atomic_fetch_and(atomic_long*, long);
long atomic_fetch_and_explicit(volatile atomic_long*, long, memory_order);
long atomic_fetch_and_explicit(atomic_long*, long, memory_order);
long atomic_fetch_or(volatile atomic_long*, long);
long atomic_fetch_or(atomic_long*, long);
long atomic_fetch_or_explicit(volatile atomic_long*, long, memory_order);
long atomic_fetch_or_explicit(atomic_long*, long, memory_order);
long atomic_fetch_xor(volatile atomic_long*, long);
long atomic_fetch_xor(atomic_long*, long);
long atomic_fetch_xor_explicit(volatile atomic_long*, long, memory_order);
long atomic_fetch_xor_explicit(atomic_long*, long, memory_order);

// atomic_ulong

typedef struct atomic_ulong
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(unsigned long, memory_order = memory_order_seq_cst) volatile;
    void store(unsigned long, memory_order = memory_order_seq_cst);
    unsigned long load(memory_order = memory_order_seq_cst) const volatile;
    unsigned long load(memory_order = memory_order_seq_cst) const;
    operator unsigned long() const volatile;
    operator unsigned long() const;
    unsigned long exchange(unsigned long,
                           memory_order = memory_order_seq_cst) volatile;
    unsigned long exchange(unsigned long, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(unsigned long&, unsigned long, memory_order,
                               memory_order) volatile;
    bool compare_exchange_weak(unsigned long&, unsigned long, memory_order,
                               memory_order);
    bool compare_exchange_strong(unsigned long&, unsigned long, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(unsigned long&, unsigned long, memory_order,
                                 memory_order);
    bool compare_exchange_weak(unsigned long&, unsigned long,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(unsigned long&, unsigned long,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(unsigned long&, unsigned long,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(unsigned long&, unsigned long,
                                 memory_order = memory_order_seq_cst);
    unsigned long fetch_add(unsigned long,
                            memory_order = memory_order_seq_cst) volatile;
    unsigned long fetch_add(unsigned long, memory_order = memory_order_seq_cst);
    unsigned long fetch_sub(unsigned long,
                            memory_order = memory_order_seq_cst) volatile;
    unsigned long fetch_sub(unsigned long, memory_order = memory_order_seq_cst);
    unsigned long fetch_and(unsigned long,
                            memory_order = memory_order_seq_cst) volatile;
    unsigned long fetch_and(unsigned long, memory_order = memory_order_seq_cst);
    unsigned long fetch_or(unsigned long,
                           memory_order = memory_order_seq_cst) volatile;
    unsigned long fetch_or(unsigned long, memory_order = memory_order_seq_cst);
    unsigned long fetch_xor(unsigned long,
                            memory_order = memory_order_seq_cst) volatile;
    unsigned long fetch_xor(unsigned long, memory_order = memory_order_seq_cst);
    atomic_ulong() = default;
    constexpr atomic_ulong(unsigned long);
    atomic_ulong(const atomic_ulong&) = delete;
    atomic_ulong& operator=(const atomic_ulong&) = delete;
    atomic_ulong& operator=(const atomic_ulong&) volatile = delete;
    unsigned long operator=(unsigned long) volatile;
    unsigned long operator=(unsigned long);
    unsigned long operator++(int) volatile;
    unsigned long operator++(int);
    unsigned long operator--(int) volatile;
    unsigned long operator--(int);
    unsigned long operator++() volatile;
    unsigned long operator++();
    unsigned long operator--() volatile;
    unsigned long operator--();
    unsigned long operator+=(unsigned long) volatile;
    unsigned long operator+=(unsigned long);
    unsigned long operator-=(unsigned long) volatile;
    unsigned long operator-=(unsigned long);
    unsigned long operator&=(unsigned long) volatile;
    unsigned long operator&=(unsigned long);
    unsigned long operator|=(unsigned long) volatile;
    unsigned long operator|=(unsigned long);
    unsigned long operator^=(unsigned long) volatile;
    unsigned long operator^=(unsigned long);
} atomic_ulong;

bool atomic_is_lock_free(const volatile atomic_ulong*);
bool atomic_is_lock_free(const atomic_ulong*);
void atomic_init(volatile atomic_ulong*, unsigned long);
void atomic_init(atomic_ulong*, unsigned long);
void atomic_store(volatile atomic_ulong*, unsigned long);
void atomic_store(atomic_ulong*, unsigned long);
void atomic_store_explicit(volatile atomic_ulong*, unsigned long, memory_order);
void atomic_store_explicit(atomic_ulong*, unsigned long, memory_order);
unsigned long atomic_load(const volatile atomic_ulong*);
unsigned long atomic_load(const atomic_ulong*);
unsigned long atomic_load_explicit(const volatile atomic_ulong*, memory_order);
unsigned long atomic_load_explicit(const atomic_ulong*, memory_order);
unsigned long atomic_exchange(volatile atomic_ulong*, unsigned long);
unsigned long atomic_exchange(atomic_ulong*, unsigned long);
unsigned long atomic_exchange_explicit(volatile atomic_ulong*, unsigned long,
                                       memory_order);
unsigned long atomic_exchange_explicit(atomic_ulong*, unsigned long,
                                       memory_order);
bool atomic_compare_exchange_weak(volatile atomic_ulong*, unsigned long*,
                                  unsigned long);
bool atomic_compare_exchange_weak(atomic_ulong*, unsigned long*, unsigned long);
bool atomic_compare_exchange_strong(volatile atomic_ulong*, unsigned long*,
                                    unsigned long);
bool atomic_compare_exchange_strong(atomic_ulong*, unsigned long*,
                                    unsigned long);
bool atomic_compare_exchange_weak_explicit(volatile atomic_ulong*,
                                           unsigned long*, unsigned long,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_ulong*, unsigned long*,
                                           unsigned long, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_ulong*,
                                             unsigned long*, unsigned long,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_ulong*, unsigned long*,
                                             unsigned long, memory_order,
                                             memory_order);
unsigned long atomic_fetch_add(volatile atomic_ulong*, unsigned long);
unsigned long atomic_fetch_add(atomic_ulong*, unsigned long);
unsigned long atomic_fetch_add_explicit(volatile atomic_ulong*, unsigned long,
                                        memory_order);
unsigned long atomic_fetch_add_explicit(atomic_ulong*, unsigned long,
                                        memory_order);
unsigned long atomic_fetch_sub(volatile atomic_ulong*, unsigned long);
unsigned long atomic_fetch_sub(atomic_ulong*, unsigned long);
unsigned long atomic_fetch_sub_explicit(volatile atomic_ulong*, unsigned long,
                                        memory_order);
unsigned long atomic_fetch_sub_explicit(atomic_ulong*, unsigned long,
                                        memory_order);
unsigned long atomic_fetch_and(volatile atomic_ulong*, unsigned long);
unsigned long atomic_fetch_and(atomic_ulong*, unsigned long);
unsigned long atomic_fetch_and_explicit(volatile atomic_ulong*, unsigned long,
                                        memory_order);
unsigned long atomic_fetch_and_explicit(atomic_ulong*, unsigned long,
                                        memory_order);
unsigned long atomic_fetch_or(volatile atomic_ulong*, unsigned long);
unsigned long atomic_fetch_or(atomic_ulong*, unsigned long);
unsigned long atomic_fetch_or_explicit(volatile atomic_ulong*, unsigned long,
                                       memory_order);
unsigned long atomic_fetch_or_explicit(atomic_ulong*, unsigned long,
                                       memory_order);
unsigned long atomic_fetch_xor(volatile atomic_ulong*, unsigned long);
unsigned long atomic_fetch_xor(atomic_ulong*, unsigned long);
unsigned long atomic_fetch_xor_explicit(volatile atomic_ulong*, unsigned long,
                                        memory_order);
unsigned long atomic_fetch_xor_explicit(atomic_ulong*, unsigned long,
                                        memory_order);

// atomic_llong

typedef struct atomic_llong
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(long long, memory_order = memory_order_seq_cst) volatile;
    void store(long long, memory_order = memory_order_seq_cst);
    long long load(memory_order = memory_order_seq_cst) const volatile;
    long long load(memory_order = memory_order_seq_cst) const;
    operator long long() const volatile;
    operator long long() const;
    long long exchange(long long, memory_order = memory_order_seq_cst) volatile;
    long long exchange(long long, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(long long&, long long, memory_order,
                               memory_order) volatile;
    bool compare_exchange_weak(long long&, long long, memory_order,
                               memory_order);
    bool compare_exchange_strong(long long&, long long, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(long long&, long long, memory_order,
                                 memory_order);
    bool compare_exchange_weak(long long&, long long,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(long long&, long long,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(long long&, long long,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(long long&, long long,
                                 memory_order = memory_order_seq_cst);
    long long fetch_add(long long,
                        memory_order = memory_order_seq_cst) volatile;
    long long fetch_add(long long, memory_order = memory_order_seq_cst);
    long long fetch_sub(long long,
                        memory_order = memory_order_seq_cst) volatile;
    long long fetch_sub(long long, memory_order = memory_order_seq_cst);
    long long fetch_and(long long,
                        memory_order = memory_order_seq_cst) volatile;
    long long fetch_and(long long, memory_order = memory_order_seq_cst);
    long long fetch_or(long long, memory_order = memory_order_seq_cst) volatile;
    long long fetch_or(long long, memory_order = memory_order_seq_cst);
    long long fetch_xor(long long,
                        memory_order = memory_order_seq_cst) volatile;
    long long fetch_xor(long long, memory_order = memory_order_seq_cst);
    atomic_llong() = default;
    constexpr atomic_llong(long long);
    atomic_llong(const atomic_llong&) = delete;
    atomic_llong& operator=(const atomic_llong&) = delete;
    atomic_llong& operator=(const atomic_llong&) volatile = delete;
    long long operator=(long long) volatile;
    long long operator=(long long);
    long long operator++(int) volatile;
    long long operator++(int);
    long long operator--(int) volatile;
    long long operator--(int);
    long long operator++() volatile;
    long long operator++();
    long long operator--() volatile;
    long long operator--();
    long long operator+=(long long) volatile;
    long long operator+=(long long);
    long long operator-=(long long) volatile;
    long long operator-=(long long);
    long long operator&=(long long) volatile;
    long long operator&=(long long);
    long long operator|=(long long) volatile;
    long long operator|=(long long);
    long long operator^=(long long) volatile;
    long long operator^=(long long);
} atomic_llong;

bool atomic_is_lock_free(const volatile atomic_llong*);
bool atomic_is_lock_free(const atomic_llong*);
void atomic_init(volatile atomic_llong*, long long);
void atomic_init(atomic_llong*, long long);
void atomic_store(volatile atomic_llong*, long long);
void atomic_store(atomic_llong*, long long);
void atomic_store_explicit(volatile atomic_llong*, long long, memory_order);
void atomic_store_explicit(atomic_llong*, long long, memory_order);
long long atomic_load(const volatile atomic_llong*);
long long atomic_load(const atomic_llong*);
long long atomic_load_explicit(const volatile atomic_llong*, memory_order);
long long atomic_load_explicit(const atomic_llong*, memory_order);
long long atomic_exchange(volatile atomic_llong*, long long);
long long atomic_exchange(atomic_llong*, long long);
long long atomic_exchange_explicit(volatile atomic_llong*, long long,
                                   memory_order);
long long atomic_exchange_explicit(atomic_llong*, long long, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_llong*, long long*,
                                  long long);
bool atomic_compare_exchange_weak(atomic_llong*, long long*, long long);
bool atomic_compare_exchange_strong(volatile atomic_llong*, long long*,
                                    long long);
bool atomic_compare_exchange_strong(atomic_llong*, long long*, long long);
bool atomic_compare_exchange_weak_explicit(volatile atomic_llong*, long long*,
                                           long long, memory_order,
                                           memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_llong*, long long*, long long,
                                           memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_llong*, long long*,
                                             long long, memory_order,
                                             memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_llong*, long long*,
                                             long long, memory_order,
                                             memory_order);
long long atomic_fetch_add(volatile atomic_llong*, long long);
long long atomic_fetch_add(atomic_llong*, long long);
long long atomic_fetch_add_explicit(volatile atomic_llong*, long long,
                                    memory_order);
long long atomic_fetch_add_explicit(atomic_llong*, long long, memory_order);
long long atomic_fetch_sub(volatile atomic_llong*, long long);
long long atomic_fetch_sub(atomic_llong*, long long);
long long atomic_fetch_sub_explicit(volatile atomic_llong*, long long,
                                    memory_order);
long long atomic_fetch_sub_explicit(atomic_llong*, long long, memory_order);
long long atomic_fetch_and(volatile atomic_llong*, long long);
long long atomic_fetch_and(atomic_llong*, long long);
long long atomic_fetch_and_explicit(volatile atomic_llong*, long long,
                                    memory_order);
long long atomic_fetch_and_explicit(atomic_llong*, long long, memory_order);
long long atomic_fetch_or(volatile atomic_llong*, long long);
long long atomic_fetch_or(atomic_llong*, long long);
long long atomic_fetch_or_explicit(volatile atomic_llong*, long long,
                                   memory_order);
long long atomic_fetch_or_explicit(atomic_llong*, long long, memory_order);
long long atomic_fetch_xor(volatile atomic_llong*, long long);
long long atomic_fetch_xor(atomic_llong*, long long);
long long atomic_fetch_xor_explicit(volatile atomic_llong*, long long,
                                    memory_order);
long long atomic_fetch_xor_explicit(atomic_llong*, long long, memory_order);

// atomic_ullong

typedef struct atomic_ullong
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(unsigned long long,
               memory_order = memory_order_seq_cst) volatile;
    void store(unsigned long long, memory_order = memory_order_seq_cst);
    unsigned long long load(memory_order = memory_order_seq_cst) const volatile;
    unsigned long long load(memory_order = memory_order_seq_cst) const;
    operator unsigned long long() const volatile;
    operator unsigned long long() const;
    unsigned long long exchange(unsigned long long,
                                memory_order = memory_order_seq_cst) volatile;
    unsigned long long exchange(unsigned long long,
                                memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(unsigned long long&, unsigned long long,
                               memory_order, memory_order) volatile;
    bool compare_exchange_weak(unsigned long long&, unsigned long long,
                               memory_order, memory_order);
    bool compare_exchange_strong(unsigned long long&, unsigned long long,
                                 memory_order, memory_order) volatile;
    bool compare_exchange_strong(unsigned long long&, unsigned long long,
                                 memory_order, memory_order);
    bool compare_exchange_weak(unsigned long long&, unsigned long long,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(unsigned long long&, unsigned long long,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(unsigned long long&, unsigned long long,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(unsigned long long&, unsigned long long,
                                 memory_order = memory_order_seq_cst);
    unsigned long long fetch_add(unsigned long long,
                                 memory_order = memory_order_seq_cst) volatile;
    unsigned long long fetch_add(unsigned long long,
                                 memory_order = memory_order_seq_cst);
    unsigned long long fetch_sub(unsigned long long,
                                 memory_order = memory_order_seq_cst) volatile;
    unsigned long long fetch_sub(unsigned long long,
                                 memory_order = memory_order_seq_cst);
    unsigned long long fetch_and(unsigned long long,
                                 memory_order = memory_order_seq_cst) volatile;
    unsigned long long fetch_and(unsigned long long,
                                 memory_order = memory_order_seq_cst);
    unsigned long long fetch_or(unsigned long long,
                                memory_order = memory_order_seq_cst) volatile;
    unsigned long long fetch_or(unsigned long long,
                                memory_order = memory_order_seq_cst);
    unsigned long long fetch_xor(unsigned long long,
                                 memory_order = memory_order_seq_cst) volatile;
    unsigned long long fetch_xor(unsigned long long,
                                 memory_order = memory_order_seq_cst);
    atomic_ullong() = default;
    constexpr atomic_ullong(unsigned long long);
    atomic_ullong(const atomic_ullong&) = delete;
    atomic_ullong& operator=(const atomic_ullong&) = delete;
    atomic_ullong& operator=(const atomic_ullong&) volatile = delete;
    unsigned long long operator=(unsigned long long) volatile;
    unsigned long long operator=(unsigned long long);
    unsigned long long operator++(int) volatile;
    unsigned long long operator++(int);
    unsigned long long operator--(int) volatile;
    unsigned long long operator--(int);
    unsigned long long operator++() volatile;
    unsigned long long operator++();
    unsigned long long operator--() volatile;
    unsigned long long operator--();
    unsigned long long operator+=(unsigned long long) volatile;
    unsigned long long operator+=(unsigned long long);
    unsigned long long operator-=(unsigned long long) volatile;
    unsigned long long operator-=(unsigned long long);
    unsigned long long operator&=(unsigned long long) volatile;
    unsigned long long operator&=(unsigned long long);
    unsigned long long operator|=(unsigned long long) volatile;
    unsigned long long operator|=(unsigned long long);
    unsigned long long operator^=(unsigned long long) volatile;
    unsigned long long operator^=(unsigned long long);
} atomic_ullong;

bool atomic_is_lock_free(const volatile atomic_ullong*);
bool atomic_is_lock_free(const atomic_ullong*);
void atomic_init(volatile atomic_ullong*, unsigned long long);
void atomic_init(atomic_ullong*, unsigned long long);
void atomic_store(volatile atomic_ullong*, unsigned long long);
void atomic_store(atomic_ullong*, unsigned long long);
void atomic_store_explicit(volatile atomic_ullong*, unsigned long long,
                           memory_order);
void atomic_store_explicit(atomic_ullong*, unsigned long long, memory_order);
unsigned long long atomic_load(const volatile atomic_ullong*);
unsigned long long atomic_load(const atomic_ullong*);
unsigned long long atomic_load_explicit(const volatile atomic_ullong*,
                                        memory_order);
unsigned long long atomic_load_explicit(const atomic_ullong*, memory_order);
unsigned long long atomic_exchange(volatile atomic_ullong*, unsigned long long);
unsigned long long atomic_exchange(atomic_ullong*, unsigned long long);
unsigned long long atomic_exchange_explicit(volatile atomic_ullong*,
                                            unsigned long long, memory_order);
unsigned long long atomic_exchange_explicit(atomic_ullong*, unsigned long long,
                                            memory_order);
bool atomic_compare_exchange_weak(volatile atomic_ullong*, unsigned long long*,
                                  unsigned long long);
bool atomic_compare_exchange_weak(atomic_ullong*, unsigned long long*,
                                  unsigned long long);
bool atomic_compare_exchange_strong(volatile atomic_ullong*,
                                    unsigned long long*, unsigned long long);
bool atomic_compare_exchange_strong(atomic_ullong*, unsigned long long*,
                                    unsigned long long);
bool atomic_compare_exchange_weak_explicit(volatile atomic_ullong*,
                                           unsigned long long*,
                                           unsigned long long, memory_order,
                                           memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_ullong*, unsigned long long*,
                                           unsigned long long, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_ullong*,
                                             unsigned long long*,
                                             unsigned long long, memory_order,
                                             memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_ullong*,
                                             unsigned long long*,
                                             unsigned long long, memory_order,
                                             memory_order);
unsigned long long atomic_fetch_add(volatile atomic_ullong*,
                                    unsigned long long);
unsigned long long atomic_fetch_add(atomic_ullong*, unsigned long long);
unsigned long long atomic_fetch_add_explicit(volatile atomic_ullong*,
                                             unsigned long long, memory_order);
unsigned long long atomic_fetch_add_explicit(atomic_ullong*, unsigned long long,
                                             memory_order);
unsigned long long atomic_fetch_sub(volatile atomic_ullong*,
                                    unsigned long long);
unsigned long long atomic_fetch_sub(atomic_ullong*, unsigned long long);
unsigned long long atomic_fetch_sub_explicit(volatile atomic_ullong*,
                                             unsigned long long, memory_order);
unsigned long long atomic_fetch_sub_explicit(atomic_ullong*, unsigned long long,
                                             memory_order);
unsigned long long atomic_fetch_and(volatile atomic_ullong*,
                                    unsigned long long);
unsigned long long atomic_fetch_and(atomic_ullong*, unsigned long long);
unsigned long long atomic_fetch_and_explicit(volatile atomic_ullong*,
                                             unsigned long long, memory_order);
unsigned long long atomic_fetch_and_explicit(atomic_ullong*, unsigned long long,
                                             memory_order);
unsigned long long atomic_fetch_or(volatile atomic_ullong*, unsigned long long);
unsigned long long atomic_fetch_or(atomic_ullong*, unsigned long long);
unsigned long long atomic_fetch_or_explicit(volatile atomic_ullong*,
                                            unsigned long long, memory_order);
unsigned long long atomic_fetch_or_explicit(atomic_ullong*, unsigned long long,
                                            memory_order);
unsigned long long atomic_fetch_xor(volatile atomic_ullong*,
                                    unsigned long long);
unsigned long long atomic_fetch_xor(atomic_ullong*, unsigned long long);
unsigned long long atomic_fetch_xor_explicit(volatile atomic_ullong*,
                                             unsigned long long, memory_order);
unsigned long long atomic_fetch_xor_explicit(atomic_ullong*, unsigned long long,
                                             memory_order);

// atomic_char16_t

typedef struct atomic_char16_t
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(char16_t, memory_order = memory_order_seq_cst) volatile;
    void store(char16_t, memory_order = memory_order_seq_cst);
    char16_t load(memory_order = memory_order_seq_cst) const volatile;
    char16_t load(memory_order = memory_order_seq_cst) const;
    operator char16_t() const volatile;
    operator char16_t() const;
    char16_t exchange(char16_t, memory_order = memory_order_seq_cst) volatile;
    char16_t exchange(char16_t, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(char16_t&, char16_t, memory_order,
                               memory_order) volatile;
    bool compare_exchange_weak(char16_t&, char16_t, memory_order, memory_order);
    bool compare_exchange_strong(char16_t&, char16_t, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(char16_t&, char16_t,
                                 memory_order, memory_order);
    bool compare_exchange_weak(char16_t&, char16_t,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(char16_t&, char16_t,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(char16_t&, char16_t,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(char16_t&, char16_t,
                                 memory_order = memory_order_seq_cst);
    char16_t fetch_add(char16_t, memory_order = memory_order_seq_cst) volatile;
    char16_t fetch_add(char16_t, memory_order = memory_order_seq_cst);
    char16_t fetch_sub(char16_t, memory_order = memory_order_seq_cst) volatile;
    char16_t fetch_sub(char16_t, memory_order = memory_order_seq_cst);
    char16_t fetch_and(char16_t, memory_order = memory_order_seq_cst) volatile;
    char16_t fetch_and(char16_t, memory_order = memory_order_seq_cst);
    char16_t fetch_or(char16_t, memory_order = memory_order_seq_cst) volatile;
    char16_t fetch_or(char16_t, memory_order = memory_order_seq_cst);
    char16_t fetch_xor(char16_t, memory_order = memory_order_seq_cst) volatile;
    char16_t fetch_xor(char16_t, memory_order = memory_order_seq_cst);
    atomic_char16_t() = default;
    constexpr atomic_char16_t(char16_t);
    atomic_char16_t(const atomic_char16_t&) = delete;
    atomic_char16_t& operator=(const atomic_char16_t&) = delete;
    atomic_char16_t& operator=(const atomic_char16_t&) volatile = delete;
    char16_t operator=(char16_t) volatile;
    char16_t operator=(char16_t);
    char16_t operator++(int) volatile;
    char16_t operator++(int);
    char16_t operator--(int) volatile;
    char16_t operator--(int);
    char16_t operator++() volatile;
    char16_t operator++();
    char16_t operator--() volatile;
    char16_t operator--();
    char16_t operator+=(char16_t) volatile;
    char16_t operator+=(char16_t);
    char16_t operator-=(char16_t) volatile;
    char16_t operator-=(char16_t);
    char16_t operator&=(char16_t) volatile;
    char16_t operator&=(char16_t);
    char16_t operator|=(char16_t) volatile;
    char16_t operator|=(char16_t);
    char16_t operator^=(char16_t) volatile;
    char16_t operator^=(char16_t);
} atomic_char16_t;

bool atomic_is_lock_free(const volatile atomic_char16_t*);
bool atomic_is_lock_free(const atomic_char16_t*);
void atomic_init(volatile atomic_char16_t*, char16_t);
void atomic_init(atomic_char16_t*, char16_t);
void atomic_store(volatile atomic_char16_t*, char16_t);
void atomic_store(atomic_char16_t*, char16_t);
void atomic_store_explicit(volatile atomic_char16_t*, char16_t, memory_order);
void atomic_store_explicit(atomic_char16_t*, char16_t, memory_order);
char16_t atomic_load(const volatile atomic_char16_t*);
char16_t atomic_load(const atomic_char16_t*);
char16_t atomic_load_explicit(const volatile atomic_char16_t*, memory_order);
char16_t atomic_load_explicit(const atomic_char16_t*, memory_order);
char16_t atomic_exchange(volatile atomic_char16_t*, char16_t);
char16_t atomic_exchange(atomic_char16_t*, char16_t);
char16_t atomic_exchange_explicit(volatile atomic_char16_t*, char16_t,
                                  memory_order);
char16_t atomic_exchange_explicit(atomic_char16_t*, char16_t, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_char16_t*, char16_t*,
                                  char16_t);
bool atomic_compare_exchange_weak(atomic_char16_t*, char16_t*, char16_t);
bool atomic_compare_exchange_strong(volatile atomic_char16_t*, char16_t*,
                                    char16_t);
bool atomic_compare_exchange_strong(atomic_char16_t*, char16_t*, char16_t);
bool atomic_compare_exchange_weak_explicit(volatile atomic_char16_t*, char16_t*,
                                           char16_t, memory_order,
                                           memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_char16_t*, char16_t*,
                                           char16_t, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_char16_t*,
                                             char16_t*, char16_t, memory_order,
                                             memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_char16_t*, char16_t*,
                                             char16_t, memory_order,
                                             memory_order);
char16_t atomic_fetch_add(volatile atomic_char16_t*, char16_t);
char16_t atomic_fetch_add(atomic_char16_t*, char16_t);
char16_t atomic_fetch_add_explicit(volatile atomic_char16_t*, char16_t,
                                   memory_order);
char16_t atomic_fetch_add_explicit(atomic_char16_t*, char16_t, memory_order);
char16_t atomic_fetch_sub(volatile atomic_char16_t*, char16_t);
char16_t atomic_fetch_sub(atomic_char16_t*, char16_t);
char16_t atomic_fetch_sub_explicit(volatile atomic_char16_t*, char16_t,
                                   memory_order);
char16_t atomic_fetch_sub_explicit(atomic_char16_t*, char16_t, memory_order);
char16_t atomic_fetch_and(volatile atomic_char16_t*, char16_t);
char16_t atomic_fetch_and(atomic_char16_t*, char16_t);
char16_t atomic_fetch_and_explicit(volatile atomic_char16_t*, char16_t,
                                   memory_order);
char16_t atomic_fetch_and_explicit(atomic_char16_t*, char16_t, memory_order);
char16_t atomic_fetch_or(volatile atomic_char16_t*, char16_t);
char16_t atomic_fetch_or(atomic_char16_t*, char16_t);
char16_t atomic_fetch_or_explicit(volatile atomic_char16_t*, char16_t,
                                  memory_order);
char16_t atomic_fetch_or_explicit(atomic_char16_t*, char16_t, memory_order);
char16_t atomic_fetch_xor(volatile atomic_char16_t*, char16_t);
char16_t atomic_fetch_xor(atomic_char16_t*, char16_t);
char16_t atomic_fetch_xor_explicit(volatile atomic_char16_t*, char16_t,
                                   memory_order);
char16_t atomic_fetch_xor_explicit(atomic_char16_t*, char16_t, memory_order);

// atomic_char32_t

typedef struct atomic_char32_t
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(char32_t, memory_order = memory_order_seq_cst) volatile;
    void store(char32_t, memory_order = memory_order_seq_cst);
    char32_t load(memory_order = memory_order_seq_cst) const volatile;
    char32_t load(memory_order = memory_order_seq_cst) const;
    operator char32_t() const volatile;
    operator char32_t() const;
    char32_t exchange(char32_t, memory_order = memory_order_seq_cst) volatile;
    char32_t exchange(char32_t, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(char32_t&, char32_t, memory_order,
                               memory_order) volatile;
    bool compare_exchange_weak(char32_t&, char32_t, memory_order, memory_order);
    bool compare_exchange_strong(char32_t&, char32_t, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(char32_t&, char32_t,
                                 memory_order, memory_order);
    bool compare_exchange_weak(char32_t&, char32_t,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(char32_t&, char32_t,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(char32_t&, char32_t,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(char32_t&, char32_t,
                                 memory_order = memory_order_seq_cst);
    char32_t fetch_add(char32_t, memory_order = memory_order_seq_cst) volatile;
    char32_t fetch_add(char32_t, memory_order = memory_order_seq_cst);
    char32_t fetch_sub(char32_t, memory_order = memory_order_seq_cst) volatile;
    char32_t fetch_sub(char32_t, memory_order = memory_order_seq_cst);
    char32_t fetch_and(char32_t, memory_order = memory_order_seq_cst) volatile;
    char32_t fetch_and(char32_t, memory_order = memory_order_seq_cst);
    char32_t fetch_or(char32_t, memory_order = memory_order_seq_cst) volatile;
    char32_t fetch_or(char32_t, memory_order = memory_order_seq_cst);
    char32_t fetch_xor(char32_t, memory_order = memory_order_seq_cst) volatile;
    char32_t fetch_xor(char32_t, memory_order = memory_order_seq_cst);
    atomic_char32_t() = default;
    constexpr atomic_char32_t(char32_t);
    atomic_char32_t(const atomic_char32_t&) = delete;
    atomic_char32_t& operator=(const atomic_char32_t&) = delete;
    atomic_char32_t& operator=(const atomic_char32_t&) volatile = delete;
    char32_t operator=(char32_t) volatile;
    char32_t operator=(char32_t);
    char32_t operator++(int) volatile;
    char32_t operator++(int);
    char32_t operator--(int) volatile;
    char32_t operator--(int);
    char32_t operator++() volatile;
    char32_t operator++();
    char32_t operator--() volatile;
    char32_t operator--();
    char32_t operator+=(char32_t) volatile;
    char32_t operator+=(char32_t);
    char32_t operator-=(char32_t) volatile;
    char32_t operator-=(char32_t);
    char32_t operator&=(char32_t) volatile;
    char32_t operator&=(char32_t);
    char32_t operator|=(char32_t) volatile;
    char32_t operator|=(char32_t);
    char32_t operator^=(char32_t) volatile;
    char32_t operator^=(char32_t);
} atomic_char32_t;

bool atomic_is_lock_free(const volatile atomic_char32_t*);
bool atomic_is_lock_free(const atomic_char32_t*);
void atomic_init(volatile atomic_char32_t*, char32_t);
void atomic_init(atomic_char32_t*, char32_t);
void atomic_store(volatile atomic_char32_t*, char32_t);
void atomic_store(atomic_char32_t*, char32_t);
void atomic_store_explicit(volatile atomic_char32_t*, char32_t, memory_order);
void atomic_store_explicit(atomic_char32_t*, char32_t, memory_order);
char32_t atomic_load(const volatile atomic_char32_t*);
char32_t atomic_load(const atomic_char32_t*);
char32_t atomic_load_explicit(const volatile atomic_char32_t*, memory_order);
char32_t atomic_load_explicit(const atomic_char32_t*, memory_order);
char32_t atomic_exchange(volatile atomic_char32_t*, char32_t);
char32_t atomic_exchange(atomic_char32_t*, char32_t);
char32_t atomic_exchange_explicit(volatile atomic_char32_t*, char32_t,
                                  memory_order);
char32_t atomic_exchange_explicit(atomic_char32_t*, char32_t, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_char32_t*, char32_t*,
                                  char32_t);
bool atomic_compare_exchange_weak(atomic_char32_t*, char32_t*, char32_t);
bool atomic_compare_exchange_strong(volatile atomic_char32_t*, char32_t*,
                                    char32_t);
bool atomic_compare_exchange_strong(atomic_char32_t*, char32_t*, char32_t);
bool atomic_compare_exchange_weak_explicit(volatile atomic_char32_t*, char32_t*,
                                           char32_t, memory_order,
                                           memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_char32_t*, char32_t*,
                                           char32_t, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_char32_t*,
                                             char32_t*, char32_t, memory_order,
                                             memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_char32_t*, char32_t*,
                                             char32_t, memory_order,
                                             memory_order);
char32_t atomic_fetch_add(volatile atomic_char32_t*, char32_t);
char32_t atomic_fetch_add(atomic_char32_t*, char32_t);
char32_t atomic_fetch_add_explicit(volatile atomic_char32_t*, char32_t,
                                   memory_order);
char32_t atomic_fetch_add_explicit(atomic_char32_t*, char32_t, memory_order);
char32_t atomic_fetch_sub(volatile atomic_char32_t*, char32_t);
char32_t atomic_fetch_sub(atomic_char32_t*, char32_t);
char32_t atomic_fetch_sub_explicit(volatile atomic_char32_t*, char32_t,
                                   memory_order);
char32_t atomic_fetch_sub_explicit(atomic_char32_t*, char32_t, memory_order);
char32_t atomic_fetch_and(volatile atomic_char32_t*, char32_t);
char32_t atomic_fetch_and(atomic_char32_t*, char32_t);
char32_t atomic_fetch_and_explicit(volatile atomic_char32_t*, char32_t,
                                   memory_order);
char32_t atomic_fetch_and_explicit(atomic_char32_t*, char32_t, memory_order);
char32_t atomic_fetch_or(volatile atomic_char32_t*, char32_t);
char32_t atomic_fetch_or(atomic_char32_t*, char32_t);
char32_t atomic_fetch_or_explicit(volatile atomic_char32_t*, char32_t,
                                  memory_order);
char32_t atomic_fetch_or_explicit(atomic_char32_t*, char32_t, memory_order);
char32_t atomic_fetch_xor(volatile atomic_char32_t*, char32_t);
char32_t atomic_fetch_xor(atomic_char32_t*, char32_t);
char32_t atomic_fetch_xor_explicit(volatile atomic_char32_t*, char32_t,
                                   memory_order);
char32_t atomic_fetch_xor_explicit(atomic_char32_t*, char32_t, memory_order);

// atomic_wchar_t

typedef struct atomic_wchar_t
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(wchar_t, memory_order = memory_order_seq_cst) volatile;
    void store(wchar_t, memory_order = memory_order_seq_cst);
    wchar_t load(memory_order = memory_order_seq_cst) const volatile;
    wchar_t load(memory_order = memory_order_seq_cst) const;
    operator wchar_t() const volatile;
    operator wchar_t() const;
    wchar_t exchange(wchar_t, memory_order = memory_order_seq_cst) volatile;
    wchar_t exchange(wchar_t, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(wchar_t&, wchar_t, memory_order,
                               memory_order) volatile;
    bool compare_exchange_weak(wchar_t&, wchar_t, memory_order, memory_order);
    bool compare_exchange_strong(wchar_t&, wchar_t, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(wchar_t&, wchar_t, memory_order, memory_order);
    bool compare_exchange_weak(wchar_t&, wchar_t,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(wchar_t&, wchar_t,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(wchar_t&, wchar_t,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(wchar_t&, wchar_t,
                                 memory_order = memory_order_seq_cst);
    wchar_t fetch_add(wchar_t, memory_order = memory_order_seq_cst) volatile;
    wchar_t fetch_add(wchar_t, memory_order = memory_order_seq_cst);
    wchar_t fetch_sub(wchar_t, memory_order = memory_order_seq_cst) volatile;
    wchar_t fetch_sub(wchar_t, memory_order = memory_order_seq_cst);
    wchar_t fetch_and(wchar_t, memory_order = memory_order_seq_cst) volatile;
    wchar_t fetch_and(wchar_t, memory_order = memory_order_seq_cst);
    wchar_t fetch_or(wchar_t, memory_order = memory_order_seq_cst) volatile;
    wchar_t fetch_or(wchar_t, memory_order = memory_order_seq_cst);
    wchar_t fetch_xor(wchar_t, memory_order = memory_order_seq_cst) volatile;
    wchar_t fetch_xor(wchar_t, memory_order = memory_order_seq_cst);
    atomic_wchar_t() = default;
    constexpr atomic_wchar_t(wchar_t);
    atomic_wchar_t(const atomic_wchar_t&) = delete;
    atomic_wchar_t& operator=(const atomic_wchar_t&) = delete;
    atomic_wchar_t& operator=(const atomic_wchar_t&) volatile = delete;
    wchar_t operator=(wchar_t) volatile;
    wchar_t operator=(wchar_t);
    wchar_t operator++(int) volatile;
    wchar_t operator++(int);
    wchar_t operator--(int) volatile;
    wchar_t operator--(int);
    wchar_t operator++() volatile;
    wchar_t operator++();
    wchar_t operator--() volatile;
    wchar_t operator--();
    wchar_t operator+=(wchar_t) volatile;
    wchar_t operator+=(wchar_t);
    wchar_t operator-=(wchar_t) volatile;
    wchar_t operator-=(wchar_t);
    wchar_t operator&=(wchar_t) volatile;
    wchar_t operator&=(wchar_t);
    wchar_t operator|=(wchar_t) volatile;
    wchar_t operator|=(wchar_t);
    wchar_t operator^=(wchar_t) volatile;
    wchar_t operator^=(wchar_t);
} atomic_wchar_t;

bool atomic_is_lock_free(const volatile atomic_wchar_t*);
bool atomic_is_lock_free(const atomic_wchar_t*);
void atomic_init(volatile atomic_wchar_t*, wchar_t);
void atomic_init(atomic_wchar_t*, wchar_t);
void atomic_store(volatile atomic_wchar_t*, wchar_t);
void atomic_store(atomic_wchar_t*, wchar_t);
void atomic_store_explicit(volatile atomic_wchar_t*, wchar_t, memory_order);
void atomic_store_explicit(atomic_wchar_t*, wchar_t, memory_order);
wchar_t atomic_load(const volatile atomic_wchar_t*);
wchar_t atomic_load(const atomic_wchar_t*);
wchar_t atomic_load_explicit(const volatile atomic_wchar_t*, memory_order);
wchar_t atomic_load_explicit(const atomic_wchar_t*, memory_order);
wchar_t atomic_exchange(volatile atomic_wchar_t*, wchar_t);
wchar_t atomic_exchange(atomic_wchar_t*, wchar_t);
wchar_t atomic_exchange_explicit(volatile atomic_wchar_t*,
                                 wchar_t, memory_order);
wchar_t atomic_exchange_explicit(atomic_wchar_t*, wchar_t, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_wchar_t*, wchar_t*, wchar_t);
bool atomic_compare_exchange_weak(atomic_wchar_t*, wchar_t*, wchar_t);
bool atomic_compare_exchange_strong(volatile atomic_wchar_t*, wchar_t*,
                                    wchar_t);
bool atomic_compare_exchange_strong(atomic_wchar_t*, wchar_t*, wchar_t);
bool atomic_compare_exchange_weak_explicit(volatile atomic_wchar_t*, wchar_t*,
                                           wchar_t, memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_wchar_t*, wchar_t*, wchar_t,
                                           memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_wchar_t*, wchar_t*,
                                             wchar_t, memory_order,
                                             memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_wchar_t*, wchar_t*, wchar_t,
                                             memory_order, memory_order);
wchar_t atomic_fetch_add(volatile atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_add(atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_add_explicit(volatile atomic_wchar_t*, wchar_t,
                                  memory_order);
wchar_t atomic_fetch_add_explicit(atomic_wchar_t*, wchar_t, memory_order);
wchar_t atomic_fetch_sub(volatile atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_sub(atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_sub_explicit(volatile atomic_wchar_t*, wchar_t,
                                  memory_order);
wchar_t atomic_fetch_sub_explicit(atomic_wchar_t*, wchar_t, memory_order);
wchar_t atomic_fetch_and(volatile atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_and(atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_and_explicit(volatile atomic_wchar_t*, wchar_t,
                                  memory_order);
wchar_t atomic_fetch_and_explicit(atomic_wchar_t*, wchar_t, memory_order);
wchar_t atomic_fetch_or(volatile atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_or(atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_or_explicit(volatile atomic_wchar_t*, wchar_t,
                                 memory_order);
wchar_t atomic_fetch_or_explicit(atomic_wchar_t*, wchar_t, memory_order);
wchar_t atomic_fetch_xor(volatile atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_xor(atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_xor_explicit(volatile atomic_wchar_t*, wchar_t,
                                  memory_order);
wchar_t atomic_fetch_xor_explicit(atomic_wchar_t*, wchar_t, memory_order);

// Atomics for standard typedef types

typedef atomic_schar  atomic_int_least8_t;
typedef atomic_uchar  atomic_uint_least8_t;
typedef atomic_short  atomic_int_least16_t;
typedef atomic_ushort atomic_uint_least16_t;
typedef atomic_int    atomic_int_least32_t;
typedef atomic_uint   atomic_uint_least32_t;
typedef atomic_llong  atomic_int_least64_t;
typedef atomic_ullong atomic_uint_least64_t;

typedef atomic_schar  atomic_int_fast8_t;
typedef atomic_uchar  atomic_uint_fast8_t;
typedef atomic_short  atomic_int_fast16_t;
typedef atomic_ushort atomic_uint_fast16_t;
typedef atomic_int    atomic_int_fast32_t;
typedef atomic_uint   atomic_uint_fast32_t;
typedef atomic_llong  atomic_int_fast64_t;
typedef atomic_ullong atomic_uint_fast64_t;

typedef atomic_long   atomic_intptr_t;
typedef atomic_ulong  atomic_uintptr_t;
typedef atomic_ulong  atomic_size_t;
typedef atomic_long   atomic_ptrdiff_t;
typedef atomic_llong  atomic_intmax_t;
typedef atomic_ullong atomic_uintmax_t;

// address types

typedef struct atomic_address
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(void*, memory_order = memory_order_seq_cst) volatile;
    void store(void*, memory_order = memory_order_seq_cst);
    void* load(memory_order = memory_order_seq_cst) const volatile;
    void* load(memory_order = memory_order_seq_cst) const;
    operator void*() const volatile;
    operator void*() const;
    void* exchange(void*, memory_order = memory_order_seq_cst) volatile;
    void* exchange(void*, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(void*&, void*, memory_order,
                               memory_order) volatile;
    bool compare_exchange_weak(void*&, void*, memory_order, memory_order);
    bool compare_exchange_strong(void*&, void*, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(void*&, void*, memory_order, memory_order);
    bool compare_exchange_weak(void*&, void*,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(void*&, void*,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(void*&, void*,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(void*&, void*,
                                 memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(const void*&, const void*,
                               memory_order, memory_order) volatile;
    bool compare_exchange_weak(const void*&, const void*, memory_order,
                               memory_order);
    bool compare_exchange_strong(const void*&, const void*, memory_order,
                                 memory_order) volatile;
    bool compare_exchange_strong(const void*&, const void*, memory_order,
                                 memory_order);
    bool compare_exchange_weak(const void*&, const void*,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(const void*&, const void*,
                               memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(const void*&, const void*,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(const void*&, const void*,
                                 memory_order = memory_order_seq_cst);
    void* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
    void* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst);
    void* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
    void* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst);
    atomic_address() = default;
    constexpr atomic_address(void*);
    atomic_address(const atomic_address&) = delete;
    atomic_address& operator=(const atomic_address&) = delete;
    atomic_address& operator=(const atomic_address&) volatile = delete;
    void* operator=(const void*) volatile;
    void* operator=(const void*);
    void* operator+=(ptrdiff_t) volatile;
    void* operator+=(ptrdiff_t);
    void* operator-=(ptrdiff_t) volatile;
    void* operator-=(ptrdiff_t);
} atomic_address;

bool atomic_is_lock_free(const volatile atomic_address*);
bool atomic_is_lock_free(const atomic_address*);
void atomic_init(volatile atomic_address*, void*);
void atomic_init(atomic_address*, void*);
void atomic_store(volatile atomic_address*, void*);
void atomic_store(atomic_address*, void*);
void atomic_store_explicit(volatile atomic_address*, void*, memory_order);
void atomic_store_explicit(atomic_address*, void*, memory_order);
void* atomic_load(const volatile atomic_address*);
void* atomic_load(const atomic_address*);
void* atomic_load_explicit(const volatile atomic_address*, memory_order);
void* atomic_load_explicit(const atomic_address*, memory_order);
void* atomic_exchange(volatile atomic_address*, void*);
void* atomic_exchange(atomic_address*, void*);
void* atomic_exchange_explicit(volatile atomic_address*, void*, memory_order);
void* atomic_exchange_explicit(atomic_address*, void*, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_address*, void**, void*);
bool atomic_compare_exchange_weak(atomic_address*, void**, void*);
bool atomic_compare_exchange_strong(volatile atomic_address*, void**, void*);
bool atomic_compare_exchange_strong(atomic_address*, void**, void*);
bool atomic_compare_exchange_weak_explicit(volatile atomic_address*, void**,
                                           void*, memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_address*, void**, void*,
                                           memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_address*, void**,
                                             void*, memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_address*, void**, void*,
                                             memory_order, memory_order);
void* atomic_fetch_add(volatile atomic_address*, ptrdiff_t);
void* atomic_fetch_add(atomic_address*, ptrdiff_t);
void* atomic_fetch_add_explicit(volatile atomic_address*, ptrdiff_t,
                                memory_order);
void* atomic_fetch_add_explicit(atomic_address*, ptrdiff_t, memory_order);
void* atomic_fetch_sub(volatile atomic_address*, ptrdiff_t);
void* atomic_fetch_sub(atomic_address*, ptrdiff_t);
void* atomic_fetch_sub_explicit(volatile atomic_address*, ptrdiff_t,
                                memory_order);
void* atomic_fetch_sub_explicit(atomic_address*, ptrdiff_t, memory_order);

// generic types

template <class T>
struct atomic
{
    bool is_lock_free() const volatile;
    bool is_lock_free() const;
    void store(T, memory_order = memory_order_seq_cst) volatile;
    void store(T, memory_order = memory_order_seq_cst);
    T load(memory_order = memory_order_seq_cst) const volatile;
    T load(memory_order = memory_order_seq_cst) const;
    operator T() const volatile;
    operator T() const;
    T exchange(T, memory_order = memory_order_seq_cst) volatile;
    T exchange(T, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(T&, T, memory_order, memory_order) volatile;
    bool compare_exchange_weak(T&, T, memory_order, memory_order);
    bool compare_exchange_strong(T&, T, memory_order, memory_order) volatile;
    bool compare_exchange_strong(T&, T, memory_order, memory_order);
    bool compare_exchange_weak(T&, T,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(T&, T, memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(T&, T,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(T&, T, memory_order = memory_order_seq_cst);

    atomic() = default;
    constexpr atomic(T);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    T operator=(T) volatile;
    T operator=(T);
};

template <>
struct atomic<bool>
    : public atomic_bool
{
    atomic() = default;
    constexpr atomic(bool);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    bool operator=(bool) volatile;
    bool operator=(bool);
    operator bool() const volatile;
    operator bool() const;
};

template <>
struct atomic<char>
    : public atomic_char
{
    atomic() = default;
    constexpr atomic(char);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    char operator=(char) volatile;
    char operator=(char);
    operator char() const volatile;
    operator char() const;
};

template <>
struct atomic<signed char>
    : public atomic_schar
{
    atomic() = default;
    constexpr atomic(signed char);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    signed char operator=(signed char) volatile;
    signed char operator=(signed char);
    operator signed char() const volatile;
    operator signed char() const;
};

template <>
struct atomic<unsigned char>
    : public atomic_uchar
{
    atomic() = default;
    constexpr atomic(unsigned char);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    unsigned char operator=(unsigned char) volatile;
    unsigned char operator=(unsigned char);
    operator unsigned char() const volatile;
    operator unsigned char() const;
};

template <>
struct atomic<short>
    : public atomic_short
{
    atomic() = default;
    constexpr atomic(short);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    short operator=(short) volatile;
    short operator=(short);
    operator short() const volatile;
    operator short() const;
};

template <>
struct atomic<unsigned short>
    : public atomic_ushort
{
    atomic() = default;
    constexpr atomic(unsigned short);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    unsigned short operator=(unsigned short) volatile;
    unsigned short operator=(unsigned short);
    operator unsigned short() const volatile;
    operator unsigned short() const;
};

template <>
struct atomic<int>
    : public atomic_int
{
    atomic() = default;
    constexpr atomic(int);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    int operator=(int) volatile;
    int operator=(int);
    operator int() const volatile;
    operator int() const;
};

template <>
struct atomic<unsigned int>
    : public atomic_uint
{
    atomic() = default;
    constexpr atomic(unsigned int);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    unsigned int operator=(unsigned int) volatile;
    unsigned int operator=(unsigned int);
    operator unsigned int() const volatile;
    operator unsigned int() const;
};

template <>
struct atomic<long>
    : public atomic_long
{
    atomic() = default;
    constexpr atomic(long);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    long operator=(long) volatile;
    long operator=(long);
    operator long() const volatile;
    operator long() const;
};

template <>
struct atomic<unsigned long>
    : public atomic_ulong
{
    atomic() = default;
    constexpr atomic(unsigned long);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    unsigned long operator=(unsigned long) volatile;
    unsigned long operator=(unsigned long);
    operator unsigned long() const volatile;
    operator unsigned long() const;
};

template <>
struct atomic<long long>
    : public atomic_llong
{
    atomic() = default;
    constexpr atomic(long long);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    long long operator=(long long) volatile;
    long long operator=(long long);
    operator long long() const volatile;
    operator long long() const;
};

template <>
struct atomic<unsigned long long>
    : public atomic_ullong
{
    atomic() = default;
    constexpr atomic(unsigned long long);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    unsigned long long operator=(unsigned long long) volatile;
    unsigned long long operator=(unsigned long long);
    operator unsigned long long() const volatile;
    operator unsigned long long() const;
};

template <>
struct atomic<char16_t>
    : public atomic_char16_t
{
    atomic() = default;
    constexpr atomic(char16_t);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    char16_t operator=(char16_t) volatile;
    char16_t operator=(char16_t);
    operator char16_t() const volatile;
    operator char16_t() const;
};

template <>
struct atomic<char32_t>
    : public atomic_char32_t
{
    atomic() = default;
    constexpr atomic(char32_t);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    char32_t operator=(char32_t) volatile;
    char32_t operator=(char32_t);
    operator char32_t() const volatile;
    operator char32_t() const;
};

template <>
struct atomic<wchar_t>
    : public atomic_wchar_t
{
    atomic() = default;
    constexpr atomic(wchar_t);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    wchar_t operator=(wchar_t) volatile;
    wchar_t operator=(wchar_t);
    operator wchar_t() const volatile;
    operator wchar_t() const;
};

template <class T>
struct atomic<T*>
    : public atomic_address
{
    void store(T*, memory_order = memory_order_seq_cst) volatile;
    void store(T*, memory_order = memory_order_seq_cst);
    T* load(memory_order = memory_order_seq_cst) const volatile;
    T* load(memory_order = memory_order_seq_cst) const;
    operator T*() const volatile;
    operator T*() const;
    T* exchange(T*, memory_order = memory_order_seq_cst) volatile;
    T* exchange(T*, memory_order = memory_order_seq_cst);
    bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile;
    bool compare_exchange_weak(T*&, T*, memory_order, memory_order);
    bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile;
    bool compare_exchange_strong(T*&, T*, memory_order, memory_order);
    bool compare_exchange_weak(T*&, T*,
                               memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_weak(T*&, T*, memory_order = memory_order_seq_cst);
    bool compare_exchange_strong(T*&, T*,
                                 memory_order = memory_order_seq_cst) volatile;
    bool compare_exchange_strong(T*&, T*, memory_order = memory_order_seq_cst);
    T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
    T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst);
    T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile;
    T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst);
    atomic() = default;
    constexpr atomic(T*);
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    T* operator=(T*) volatile;
    T* operator=(T*);
    T* operator++(int) volatile;
    T* operator++(int);
    T* operator--(int) volatile;
    T* operator--(int);
    T* operator++() volatile;
    T* operator++();
    T* operator--() volatile;
    T* operator--();
    T* operator+=(ptrdiff_t) volatile;
    T* operator+=(ptrdiff_t);
    T* operator-=(ptrdiff_t) volatile;
    T* operator-=(ptrdiff_t);
};

// fences

void atomic_thread_fence(memory_order);
void atomic_signal_fence(memory_order);

}  // std

*/

#include <__config>

#pragma GCC system_header

_LIBCPP_BEGIN_NAMESPACE_STD

typedef enum memory_order
{
    memory_order_relaxed, memory_order_consume, memory_order_acquire,
    memory_order_release, memory_order_acq_rel, memory_order_seq_cst
} memory_order;

template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
_Tp
kill_dependency(_Tp __y)
{
    return __y;
}

// flag type and operations

typedef bool __atomic_flag__;

struct atomic_flag;

bool atomic_flag_test_and_set(volatile atomic_flag*);
bool atomic_flag_test_and_set(atomic_flag*);
bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order);
bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order);
void atomic_flag_clear(volatile atomic_flag*);
void atomic_flag_clear(atomic_flag*);
void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order);
void atomic_flag_clear_explicit(atomic_flag*, memory_order);

typedef struct _LIBCPP_VISIBLE atomic_flag
{
    __atomic_flag__ __flg_;

    _LIBCPP_INLINE_VISIBILITY
    bool test_and_set(memory_order __o = memory_order_seq_cst) volatile
        {return atomic_flag_test_and_set_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool test_and_set(memory_order __o = memory_order_seq_cst)
        {return atomic_flag_test_and_set_explicit(this, __o);}

    _LIBCPP_INLINE_VISIBILITY
    void clear(memory_order __o = memory_order_seq_cst) volatile
        {atomic_flag_clear_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void clear(memory_order __o = memory_order_seq_cst)
        {atomic_flag_clear_explicit(this, __o);}

#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_flag() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_flag() {};
#endif

#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_flag(const atomic_flag&) = delete;
    atomic_flag& operator=(const atomic_flag&) = delete;
    atomic_flag& operator=(const atomic_flag&) volatile = delete;
#else
private:
    atomic_flag(const atomic_flag&);
    atomic_flag& operator=(const atomic_flag&);
    atomic_flag& operator=(const atomic_flag&) volatile;
public:
#endif
} atomic_flag;

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_flag_test_and_set(volatile atomic_flag* __f)
{
    return __atomic_exchange(&__f->__flg_, __atomic_flag__(true),
                             memory_order_seq_cst)
            == __atomic_flag__(true);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_flag_test_and_set(atomic_flag* __f)
{
    return atomic_flag_test_and_set(const_cast<volatile atomic_flag*>(__f));
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_flag_test_and_set_explicit(volatile atomic_flag* __f, memory_order __o)
{
    return __atomic_exchange(&__f->__flg_, __atomic_flag__(true), __o)
            == __atomic_flag__(true);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_flag_test_and_set_explicit(atomic_flag* __f, memory_order __o)
{
    return atomic_flag_test_and_set_explicit(const_cast<volatile atomic_flag*>
                                                                    (__f), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_flag_clear(volatile atomic_flag* __f)
{
    __atomic_store(&__f->__flg_, __atomic_flag__(false), memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_flag_clear(atomic_flag* __f)
{
    atomic_flag_clear(const_cast<volatile atomic_flag*>(__f));
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_flag_clear_explicit(volatile atomic_flag* __f, memory_order __o)
{
    __atomic_store(&__f->__flg_, __atomic_flag__(false), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_flag_clear_explicit(atomic_flag* __f, memory_order __o)
{
    atomic_flag_clear_explicit(const_cast<volatile atomic_flag*>(__f), __o);
}

#define ATOMIC_FLAG_INIT {false}
#define ATOMIC_VAR_INIT(__v) {__v}

inline _LIBCPP_INLINE_VISIBILITY
memory_order
__translate_memory_order(memory_order __o)
{
    switch (__o)
    {
    case memory_order_acq_rel:
        return memory_order_acquire;
    case memory_order_release:
        return memory_order_relaxed;
    }
    return __o;
}

// atomic_bool

struct atomic_bool;

bool atomic_is_lock_free(const volatile atomic_bool*);
bool atomic_is_lock_free(const atomic_bool*);
void atomic_init(volatile atomic_bool*, bool);
void atomic_init(atomic_bool*, bool);
void atomic_store(volatile atomic_bool*, bool);
void atomic_store(atomic_bool*, bool);
void atomic_store_explicit(volatile atomic_bool*, bool, memory_order);
void atomic_store_explicit(atomic_bool*, bool, memory_order);
bool atomic_load(const volatile atomic_bool*);
bool atomic_load(const atomic_bool*);
bool atomic_load_explicit(const volatile atomic_bool*, memory_order);
bool atomic_load_explicit(const atomic_bool*, memory_order);
bool atomic_exchange(volatile atomic_bool*, bool);
bool atomic_exchange(atomic_bool*, bool);
bool atomic_exchange_explicit(volatile atomic_bool*, bool, memory_order);
bool atomic_exchange_explicit(atomic_bool*, bool, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_bool*, bool*, bool);
bool atomic_compare_exchange_weak(atomic_bool*, bool*, bool);
bool atomic_compare_exchange_strong(volatile atomic_bool*, bool*, bool);
bool atomic_compare_exchange_strong(atomic_bool*, bool*, bool);
bool atomic_compare_exchange_weak_explicit(volatile atomic_bool*, bool*, bool,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_bool*, bool*, bool,
                                           memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_bool*, bool*, bool,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_bool*, bool*, bool,
                                             memory_order, memory_order);

typedef struct atomic_bool
{
    bool __v_;

    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const volatile
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    void store(bool __v, memory_order __o = memory_order_seq_cst) volatile
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void store(bool __v, memory_order __o = memory_order_seq_cst)
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool load(memory_order __o = memory_order_seq_cst) const volatile
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool load(memory_order __o = memory_order_seq_cst) const
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    operator bool() const volatile
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    operator bool() const
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    bool exchange(bool __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool exchange(bool __v, memory_order __o = memory_order_seq_cst)
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(bool& __v, bool __e, memory_order __s,
                               memory_order __f) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(bool& __v, bool __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(bool& __v, bool __e, memory_order __s,
                               memory_order __f)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(bool& __v, bool __e,
                               memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(bool& __v, bool __e, memory_order __s,
                                 memory_order __f) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(bool& __v, bool __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(bool& __v, bool __e, memory_order __s,
                                 memory_order __f)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(bool& __v, bool __e,
                                 memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_bool() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_bool() {}
#endif
    _LIBCPP_INLINE_VISIBILITY
    /*constexpr*/ atomic_bool(bool __v)
        : __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_bool(const atomic_bool&) = delete;
    atomic_bool& operator=(const atomic_bool&) = delete;
    atomic_bool& operator=(const atomic_bool&) volatile = delete;
#else
private:
    atomic_bool(const atomic_bool&);
    atomic_bool& operator=(const atomic_bool&);
    atomic_bool& operator=(const atomic_bool&) volatile;
public:
#endif
    _LIBCPP_INLINE_VISIBILITY
    bool operator=(bool __v) volatile
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    bool operator=(bool __v)
        {store(__v); return __v;}
} atomic_bool;

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_is_lock_free(const volatile atomic_bool*)
{
    typedef bool type;
    return __atomic_is_lock_free(type);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_is_lock_free(const atomic_bool* __obj)
{
    return atomic_is_lock_free(const_cast<const volatile atomic_bool*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
void atomic_init(volatile atomic_bool* __obj, bool __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void atomic_init(atomic_bool* __obj, bool __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void atomic_store(volatile atomic_bool* __obj, bool __desr)
{
    __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void atomic_store(atomic_bool* __obj, bool __desr)
{
    atomic_store(const_cast<volatile atomic_bool*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
void atomic_store_explicit(volatile atomic_bool* __obj, bool __desr,
                           memory_order __o)
{
    __atomic_store(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void atomic_store_explicit(atomic_bool* __obj, bool __desr, memory_order __o)
{
    atomic_store_explicit(const_cast<volatile atomic_bool*>(__obj), __desr,
                                                                           __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_load(const volatile atomic_bool* __obj)
{
    return __atomic_load(&__obj->__v_, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_load(const atomic_bool* __obj)
{
    return atomic_load(const_cast<const volatile atomic_bool*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_load_explicit(const volatile atomic_bool* __obj, memory_order __o)
{
    return __atomic_load(&__obj->__v_, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_load_explicit(const atomic_bool* __obj, memory_order __o)
{
    return atomic_load_explicit(const_cast<const volatile atomic_bool*>
                                                                  (__obj), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_exchange(volatile atomic_bool* __obj, bool __desr)
{
    return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_exchange(atomic_bool* __obj, bool __desr)
{
    return atomic_exchange(const_cast<volatile atomic_bool*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_exchange_explicit(volatile atomic_bool* __obj, bool __desr,
                              memory_order __o)
{
    return __atomic_exchange(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_exchange_explicit(atomic_bool* __obj, bool __desr, memory_order __o)
{
    return atomic_exchange_explicit(const_cast<volatile atomic_bool*>
                                                          (__obj), __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_compare_exchange_weak(volatile atomic_bool* __obj, bool* __exp,
                                  bool __desr)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_compare_exchange_weak(atomic_bool* __obj, bool* __exp, bool __desr)
{
    return atomic_compare_exchange_weak(const_cast<volatile atomic_bool*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_compare_exchange_weak_explicit(volatile atomic_bool* __obj,
                                           bool* __exp, bool __desr,
                                           memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_compare_exchange_weak_explicit(atomic_bool* __obj, bool* __exp,
                                           bool __desr,
                                           memory_order __s, memory_order __f)
{
    return atomic_compare_exchange_weak_explicit(
             const_cast<volatile atomic_bool*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_compare_exchange_strong(volatile atomic_bool* __obj, bool* __exp,
                                    bool __desr)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_compare_exchange_strong(atomic_bool* __obj, bool* __exp,
                                    bool __desr)
{
    return atomic_compare_exchange_strong(const_cast<volatile atomic_bool*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_compare_exchange_strong_explicit(volatile atomic_bool* __obj,
                                             bool* __exp, bool __desr,
                                             memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool atomic_compare_exchange_strong_explicit(atomic_bool* __obj, bool* __exp,
                                             bool __desr,
                                             memory_order __s, memory_order __f)
{
    return atomic_compare_exchange_strong_explicit(
             const_cast<volatile atomic_bool*>(__obj), __exp, __desr, __s, __f);
}

// atomic_char

struct atomic_char;

bool atomic_is_lock_free(const volatile atomic_char*);
bool atomic_is_lock_free(const atomic_char*);
void atomic_init(volatile atomic_char*, char);
void atomic_init(atomic_char*, char);
void atomic_store(volatile atomic_char*, char);
void atomic_store(atomic_char*, char);
void atomic_store_explicit(volatile atomic_char*, char, memory_order);
void atomic_store_explicit(atomic_char*, char, memory_order);
char atomic_load(const volatile atomic_char*);
char atomic_load(const atomic_char*);
char atomic_load_explicit(const volatile atomic_char*, memory_order);
char atomic_load_explicit(const atomic_char*, memory_order);
char atomic_exchange(volatile atomic_char*, char);
char atomic_exchange(atomic_char*, char);
char atomic_exchange_explicit(volatile atomic_char*, char, memory_order);
char atomic_exchange_explicit(atomic_char*, char, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_char*, char*, char);
bool atomic_compare_exchange_weak(atomic_char*, char*, char);
bool atomic_compare_exchange_strong(volatile atomic_char*, char*, char);
bool atomic_compare_exchange_strong(atomic_char*, char*, char);
bool atomic_compare_exchange_weak_explicit(volatile atomic_char*, char*, char,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_char*, char*, char,
                                           memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_char*, char*, char,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_char*, char*, char,
                                             memory_order, memory_order);
char atomic_fetch_add(volatile atomic_char*, char);
char atomic_fetch_add(atomic_char*, char);
char atomic_fetch_add_explicit(volatile atomic_char*, char, memory_order);
char atomic_fetch_add_explicit(atomic_char*, char, memory_order);
char atomic_fetch_sub(volatile atomic_char*, char);
char atomic_fetch_sub(atomic_char*, char);
char atomic_fetch_sub_explicit(volatile atomic_char*, char, memory_order);
char atomic_fetch_sub_explicit(atomic_char*, char, memory_order);
char atomic_fetch_and(volatile atomic_char*, char);
char atomic_fetch_and(atomic_char*, char);
char atomic_fetch_and_explicit(volatile atomic_char*, char, memory_order);
char atomic_fetch_and_explicit(atomic_char*, char, memory_order);
char atomic_fetch_or(volatile atomic_char*, char);
char atomic_fetch_or(atomic_char*, char);
char atomic_fetch_or_explicit(volatile atomic_char*, char, memory_order);
char atomic_fetch_or_explicit(atomic_char*, char, memory_order);
char atomic_fetch_xor(volatile atomic_char*, char);
char atomic_fetch_xor(atomic_char*, char);
char atomic_fetch_xor_explicit(volatile atomic_char*, char, memory_order);
char atomic_fetch_xor_explicit(atomic_char*, char, memory_order);

typedef struct atomic_char
{
    char __v_;

    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const volatile
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    void store(char __v, memory_order __o = memory_order_seq_cst) volatile
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void store(char __v, memory_order __o = memory_order_seq_cst)
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char load(memory_order __o = memory_order_seq_cst) const volatile
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char load(memory_order __o = memory_order_seq_cst) const
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    operator char() const volatile
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    operator char() const
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    char exchange(char __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char exchange(char __v, memory_order __o = memory_order_seq_cst)
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(char& __v, char __e, memory_order __s,
                               memory_order __f) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(char& __v, char __e, memory_order __s,
                               memory_order __f)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(char& __v, char __e, memory_order __s,
                                 memory_order __f) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(char& __v, char __e, memory_order __s,
                                 memory_order __f)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(char& __v, char __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(char& __v, char __e,
                               memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(char& __v, char __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(char& __v, char __e,
                                 memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    char fetch_add(char __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char fetch_add(char __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char fetch_sub(char __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char fetch_sub(char __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char fetch_and(char __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char fetch_and(char __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char fetch_or(char __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char fetch_or(char __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char fetch_xor(char __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_xor_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char fetch_xor(char __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_xor_explicit(this, __v, __o);}
#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_char() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_char() {}
#endif
    _LIBCPP_INLINE_VISIBILITY
    /*constexpr*/ atomic_char(char __v)
        : __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_char(const atomic_char&) = delete;
    atomic_char& operator=(const atomic_char&) = delete;
    atomic_char& operator=(const atomic_char&) volatile = delete;
#else
private:
    atomic_char(const atomic_char&);
    atomic_char& operator=(const atomic_char&);
    atomic_char& operator=(const atomic_char&) volatile;
public:
#endif
    _LIBCPP_INLINE_VISIBILITY
    char operator=(char __v) volatile
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    char operator=(char __v)
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    char operator++(int) volatile
        {return fetch_add(char(1));}
    _LIBCPP_INLINE_VISIBILITY
    char operator++(int)
        {return fetch_add(char(1));}
    _LIBCPP_INLINE_VISIBILITY
    char operator--(int) volatile
        {return fetch_sub(char(1));}
    _LIBCPP_INLINE_VISIBILITY
    char operator--(int)
        {return fetch_sub(char(1));}
    _LIBCPP_INLINE_VISIBILITY
    char operator++() volatile
        {return char(fetch_add(char(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    char operator++()
        {return char(fetch_add(char(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    char operator--() volatile
        {return char(fetch_sub(char(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    char operator--()
        {return char(fetch_sub(char(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    char operator+=(char __v) volatile
        {return char(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator+=(char __v)
        {return char(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator-=(char __v) volatile
        {return char(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator-=(char __v)
        {return char(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator&=(char __v) volatile
        {return char(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator&=(char __v)
        {return char(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator|=(char __v) volatile
        {return char(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator|=(char __v)
        {return char(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator^=(char __v) volatile
        {return char(fetch_xor(__v) ^ __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator^=(char __v)
        {return char(fetch_xor(__v) ^ __v);}
} atomic_char;

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const volatile atomic_char*)
{
    typedef char type;
    return __atomic_is_lock_free(type);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const atomic_char* __obj)
{
    return atomic_is_lock_free(const_cast<volatile atomic_char*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(volatile atomic_char* __obj, char __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(atomic_char* __obj, char __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(volatile atomic_char* __obj, char __desr)
{
    __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(atomic_char* __obj, char __desr)
{
    atomic_store(const_cast<volatile atomic_char*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(volatile atomic_char* __obj, char __desr,
                      memory_order __o)
{
    __atomic_store(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(atomic_char* __obj, char __desr, memory_order __o)
{
    atomic_store_explicit(const_cast<volatile atomic_char*>(__obj), __desr,
                                                                           __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_load(const volatile atomic_char* __obj)
{
    return __atomic_load(&__obj->__v_, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_load(const atomic_char* __obj)
{
    return atomic_load(const_cast<const volatile atomic_char*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_load_explicit(const volatile atomic_char* __obj, memory_order __o)
{
    return __atomic_load(&__obj->__v_, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_load_explicit(const atomic_char* __obj, memory_order __o)
{
    return atomic_load_explicit(const_cast<const volatile atomic_char*>
                                                                  (__obj), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_exchange(volatile atomic_char* __obj, char __desr)
{
    return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_exchange(atomic_char* __obj, char __desr)
{
    return atomic_exchange(const_cast<volatile atomic_char*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_exchange_explicit(volatile atomic_char* __obj, char __desr,
                         memory_order __o)
{
    return __atomic_exchange(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_exchange_explicit(atomic_char* __obj, char __desr, memory_order __o)
{
    return atomic_exchange_explicit(const_cast<volatile atomic_char*>
                                                          (__obj), __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(volatile atomic_char* __obj, char* __exp,
                             char __desr)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(atomic_char* __obj, char* __exp, char __desr)
{
    return atomic_compare_exchange_weak(const_cast<volatile atomic_char*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(volatile atomic_char* __obj, char* __exp,
                               char __desr)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(atomic_char* __obj, char* __exp, char __desr)
{
    return atomic_compare_exchange_strong(const_cast<volatile atomic_char*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(volatile atomic_char* __obj, char* __exp,
                                      char __desr, memory_order __s,
                                      memory_order __f)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(atomic_char* __obj, char* __exp,
                                      char __desr, memory_order __s,
                                      memory_order __f)
{
    return atomic_compare_exchange_weak_explicit(
             const_cast<volatile atomic_char*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(volatile atomic_char* __obj,
                                        char* __exp, char __desr,
                                        memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(atomic_char* __obj, char* __exp,
                                        char __desr, memory_order __s,
                                        memory_order __f)
{
    return atomic_compare_exchange_strong_explicit(
             const_cast<volatile atomic_char*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_add(volatile atomic_char* __obj, char __v)
{
    return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_add(atomic_char* __obj, char __v)
{
    return atomic_fetch_add(const_cast<volatile atomic_char*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_add_explicit(volatile atomic_char* __obj, char __v,
                          memory_order __o)
{
    return __atomic_fetch_add(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_add_explicit(atomic_char* __obj, char __v, memory_order __o)
{
    return atomic_fetch_add_explicit(const_cast<volatile atomic_char*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_sub(volatile atomic_char* __obj, char __v)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_sub(atomic_char* __obj, char __v)
{
    return atomic_fetch_sub(const_cast<volatile atomic_char*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_sub_explicit(volatile atomic_char* __obj, char __v,
                          memory_order __o)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_sub_explicit(atomic_char* __obj, char __v, memory_order __o)
{
    return atomic_fetch_sub_explicit(const_cast<volatile atomic_char*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_and(volatile atomic_char* __obj, char __v)
{
    return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_and(atomic_char* __obj, char __v)
{
    return atomic_fetch_and(const_cast<volatile atomic_char*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_and_explicit(volatile atomic_char* __obj, char __v,
                          memory_order __o)
{
    return __atomic_fetch_and(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_and_explicit(atomic_char* __obj, char __v, memory_order __o)
{
    return atomic_fetch_and_explicit(const_cast<volatile atomic_char*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_or(volatile atomic_char* __obj, char __v)
{
    return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_or(atomic_char* __obj, char __v)
{
    return atomic_fetch_or(const_cast<volatile atomic_char*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_or_explicit(volatile atomic_char* __obj, char __v,
                         memory_order __o)
{
    return __atomic_fetch_or(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_or_explicit(atomic_char* __obj, char __v, memory_order __o)
{
    return atomic_fetch_or_explicit(const_cast<volatile atomic_char*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_xor(volatile atomic_char* __obj, char __v)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_xor(atomic_char* __obj, char __v)
{
    return atomic_fetch_xor(const_cast<volatile atomic_char*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_xor_explicit(volatile atomic_char* __obj, char __v,
                          memory_order __o)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char
atomic_fetch_xor_explicit(atomic_char* __obj, char __v, memory_order __o)
{
    return atomic_fetch_xor_explicit(const_cast<volatile atomic_char*>(__obj),
                                                                      __v, __o);
}

// atomic_schar

struct atomic_schar;

bool atomic_is_lock_free(const volatile atomic_schar*);
bool atomic_is_lock_free(const atomic_schar*);
void atomic_init(volatile atomic_schar*, signed char);
void atomic_init(atomic_schar*, signed char);
void atomic_store(volatile atomic_schar*, signed char);
void atomic_store(atomic_schar*, signed char);
void atomic_store_explicit(volatile atomic_schar*, signed char, memory_order);
void atomic_store_explicit(atomic_schar*, signed char, memory_order);
signed char atomic_load(const volatile atomic_schar*);
signed char atomic_load(const atomic_schar*);
signed char atomic_load_explicit(const volatile atomic_schar*, memory_order);
signed char atomic_load_explicit(const atomic_schar*, memory_order);
signed char atomic_exchange(volatile atomic_schar*, signed char);
signed char atomic_exchange(atomic_schar*, signed char);
signed char atomic_exchange_explicit(volatile atomic_schar*, signed char,
                                     memory_order);
signed char atomic_exchange_explicit(atomic_schar*, signed char, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_schar*, signed char*,
                                  signed char);
bool atomic_compare_exchange_weak(atomic_schar*, signed char*, signed char);
bool atomic_compare_exchange_strong(volatile atomic_schar*, signed char*,
                                    signed char);
bool atomic_compare_exchange_strong(atomic_schar*, signed char*, signed char);
bool atomic_compare_exchange_weak_explicit(volatile atomic_schar*, signed char*,
                                           signed char, memory_order,
                                           memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_schar*, signed char*,
                                           signed char, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_schar*,
                                             signed char*, signed char,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_schar*, signed char*,
                                             signed char, memory_order,
                                             memory_order);
signed char atomic_fetch_add(volatile atomic_schar*, signed char);
signed char atomic_fetch_add(atomic_schar*, signed char);
signed char atomic_fetch_add_explicit(volatile atomic_schar*, signed char,
                                      memory_order);
signed char atomic_fetch_add_explicit(atomic_schar*, signed char, memory_order);
signed char atomic_fetch_sub(volatile atomic_schar*, signed char);
signed char atomic_fetch_sub(atomic_schar*, signed char);
signed char atomic_fetch_sub_explicit(volatile atomic_schar*, signed char,
                                      memory_order);
signed char atomic_fetch_sub_explicit(atomic_schar*, signed char, memory_order);
signed char atomic_fetch_and(volatile atomic_schar*, signed char);
signed char atomic_fetch_and(atomic_schar*, signed char);
signed char atomic_fetch_and_explicit(volatile atomic_schar*, signed char,
                                      memory_order);
signed char atomic_fetch_and_explicit(atomic_schar*, signed char, memory_order);
signed char atomic_fetch_or(volatile atomic_schar*, signed char);
signed char atomic_fetch_or(atomic_schar*, signed char);
signed char atomic_fetch_or_explicit(volatile atomic_schar*, signed char,
                                     memory_order);
signed char atomic_fetch_or_explicit(atomic_schar*, signed char, memory_order);
signed char atomic_fetch_xor(volatile atomic_schar*, signed char);
signed char atomic_fetch_xor(atomic_schar*, signed char);
signed char atomic_fetch_xor_explicit(volatile atomic_schar*, signed char,
                                      memory_order);
signed char atomic_fetch_xor_explicit(atomic_schar*, signed char, memory_order);

typedef struct atomic_schar
{
    signed char __v_;

    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const volatile
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    void store(signed char __v,
               memory_order __o = memory_order_seq_cst) volatile
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void store(signed char __v, memory_order __o = memory_order_seq_cst)
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    signed char load(memory_order __o = memory_order_seq_cst) const volatile
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    signed char load(memory_order __o = memory_order_seq_cst) const
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    operator signed char() const volatile
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    operator signed char() const
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    signed char exchange(signed char __v,
                         memory_order __o = memory_order_seq_cst) volatile
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    signed char exchange(signed char __v,
                         memory_order __o = memory_order_seq_cst)
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(signed char& __v, signed char __e,
                               memory_order __s, memory_order __f) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(signed char& __v, signed char __e,
                               memory_order __s, memory_order __f)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(signed char& __v, signed char __e,
                                 memory_order __s, memory_order __f) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(signed char& __v, signed char __e,
                                 memory_order __s, memory_order __f)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(signed char& __v, signed char __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(signed char& __v, signed char __e,
                               memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(signed char& __v, signed char __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(signed char& __v, signed char __e,
                                 memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    signed char fetch_add(signed char __v,
                          memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    signed char fetch_add(signed char __v,
                          memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    signed char fetch_sub(signed char __v,
                          memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    signed char fetch_sub(signed char __v,
                          memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    signed char fetch_and(signed char __v,
                          memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    signed char fetch_and(signed char __v,
                          memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    signed char fetch_or(signed char __v,
                         memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    signed char fetch_or(signed char __v,
                         memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    signed char fetch_xor(signed char __v,
                          memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_xor_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    signed char fetch_xor(signed char __v,
                          memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_xor_explicit(this, __v, __o);}
#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_schar() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_schar() {}
#endif
    _LIBCPP_INLINE_VISIBILITY
    /*constexpr*/ atomic_schar(signed char __v)
        : __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_schar(const atomic_schar&) = delete;
    atomic_schar& operator=(const atomic_schar&) = delete;
    atomic_schar& operator=(const atomic_schar&) volatile = delete;
#else
private:
    atomic_schar(const atomic_schar&);
    atomic_schar& operator=(const atomic_schar&);
    atomic_schar& operator=(const atomic_schar&) volatile;
public:
#endif
    _LIBCPP_INLINE_VISIBILITY
    signed char operator=(signed char __v) volatile
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    signed char operator=(signed char __v)
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    signed char operator++(int) volatile
        {typedef signed char type; return fetch_add(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    char operator++(int)
        {typedef signed char type; return fetch_add(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    char operator--(int) volatile
        {typedef signed char type; return fetch_sub(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    char operator--(int)
        {typedef signed char type; return fetch_sub(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    char operator++() volatile
        {typedef signed char type; return type(fetch_add(type(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    char operator++()
        {typedef signed char type; return type(fetch_add(type(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    char operator--() volatile
        {typedef signed char type; return type(fetch_sub(type(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    char operator--()
        {typedef signed char type; return type(fetch_sub(type(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    char operator+=(char __v) volatile
        {typedef signed char type; return type(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator+=(char __v)
        {typedef signed char type; return type(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator-=(char __v) volatile
        {typedef signed char type; return type(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator-=(char __v)
        {typedef signed char type; return type(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator&=(char __v) volatile
        {typedef signed char type; return type(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator&=(char __v)
        {typedef signed char type; return type(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator|=(char __v) volatile
        {typedef signed char type; return type(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator|=(char __v)
        {typedef signed char type; return type(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator^=(char __v) volatile
        {typedef signed char type; return type(fetch_xor(__v) ^ __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator^=(char __v)
        {typedef signed char type; return type(fetch_xor(__v) ^ __v);}
} atomic_schar;

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const volatile atomic_schar*)
{
    typedef signed char type;
    return __atomic_is_lock_free(type);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const atomic_schar* __obj)
{
    return atomic_is_lock_free(const_cast<volatile atomic_schar*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(volatile atomic_schar* __obj, signed char __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(atomic_schar* __obj, signed char __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(volatile atomic_schar* __obj, signed char __desr)
{
    __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(atomic_schar* __obj, signed char __desr)
{
    atomic_store(const_cast<volatile atomic_schar*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(volatile atomic_schar* __obj, signed char __desr,
                      memory_order __o)
{
    __atomic_store(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(atomic_schar* __obj, signed char __desr, memory_order __o)
{
    atomic_store_explicit(const_cast<volatile atomic_schar*>(__obj), __desr,
                                                                           __o);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_load(const volatile atomic_schar* __obj)
{
    return __atomic_load(&__obj->__v_, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_load(const atomic_schar* __obj)
{
    return atomic_load(const_cast<const volatile atomic_schar*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_load_explicit(const volatile atomic_schar* __obj, memory_order __o)
{
    return __atomic_load(&__obj->__v_, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_load_explicit(const atomic_schar* __obj, memory_order __o)
{
    return atomic_load_explicit(const_cast<const volatile atomic_schar*>
                                                                  (__obj), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_exchange(volatile atomic_schar* __obj, signed char __desr)
{
    return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_exchange(atomic_schar* __obj, signed char __desr)
{
    return atomic_exchange(const_cast<volatile atomic_schar*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_exchange_explicit(volatile atomic_schar* __obj, signed char __desr,
                         memory_order __o)
{
    return __atomic_exchange(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_exchange_explicit(atomic_schar* __obj, signed char __desr,
                         memory_order __o)
{
    return atomic_exchange_explicit(const_cast<volatile atomic_schar*>
                                                          (__obj), __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(volatile atomic_schar* __obj, signed char* __exp,
                             signed char __desr)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(atomic_schar* __obj, signed char* __exp,
                             signed char __desr)
{
    return atomic_compare_exchange_weak(const_cast<volatile atomic_schar*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(volatile atomic_schar* __obj, signed char* __exp,
                               signed char __desr)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(atomic_schar* __obj, signed char* __exp,
                               signed char __desr)
{
    return atomic_compare_exchange_strong(const_cast<volatile atomic_schar*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(volatile atomic_schar* __obj,
                                      signed char* __exp, signed char __desr,
                                      memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(atomic_schar* __obj, signed char* __exp,
                                      signed char __desr, memory_order __s,
                                      memory_order __f)
{
    return atomic_compare_exchange_weak_explicit(
             const_cast<volatile atomic_schar*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(volatile atomic_schar* __obj,
                                        signed char* __exp, signed char __desr,
                                        memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(atomic_schar* __obj, signed char* __exp,
                                        signed char __desr, memory_order __s,
                                        memory_order __f)
{
    return atomic_compare_exchange_strong_explicit(
             const_cast<volatile atomic_schar*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_add(volatile atomic_schar* __obj, signed char __v)
{
    return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_add(atomic_schar* __obj, signed char __v)
{
    return atomic_fetch_add(const_cast<volatile atomic_schar*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_add_explicit(volatile atomic_schar* __obj, signed char __v,
                          memory_order __o)
{
    return __atomic_fetch_add(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_add_explicit(atomic_schar* __obj, signed char __v,
                          memory_order __o)
{
    return atomic_fetch_add_explicit(const_cast<volatile atomic_schar*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_sub(volatile atomic_schar* __obj, signed char __v)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_sub(atomic_schar* __obj, signed char __v)
{
    return atomic_fetch_sub(const_cast<volatile atomic_schar*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_sub_explicit(volatile atomic_schar* __obj, signed char __v,
                          memory_order __o)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_sub_explicit(atomic_schar* __obj, signed char __v,
                          memory_order __o)
{
    return atomic_fetch_sub_explicit(const_cast<volatile atomic_schar*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_and(volatile atomic_schar* __obj, signed char __v)
{
    return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_and(atomic_schar* __obj, signed char __v)
{
    return atomic_fetch_and(const_cast<volatile atomic_schar*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_and_explicit(volatile atomic_schar* __obj, signed char __v,
                          memory_order __o)
{
    return __atomic_fetch_and(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_and_explicit(atomic_schar* __obj, signed char __v,
                          memory_order __o)
{
    return atomic_fetch_and_explicit(const_cast<volatile atomic_schar*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_or(volatile atomic_schar* __obj, signed char __v)
{
    return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_or(atomic_schar* __obj, signed char __v)
{
    return atomic_fetch_or(const_cast<volatile atomic_schar*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_or_explicit(volatile atomic_schar* __obj, signed char __v,
                         memory_order __o)
{
    return __atomic_fetch_or(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_or_explicit(atomic_schar* __obj, signed char __v, memory_order __o)
{
    return atomic_fetch_or_explicit(const_cast<volatile atomic_schar*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_xor(volatile atomic_schar* __obj, signed char __v)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_xor(atomic_schar* __obj, signed char __v)
{
    return atomic_fetch_xor(const_cast<volatile atomic_schar*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_xor_explicit(volatile atomic_schar* __obj, signed char __v,
                          memory_order __o)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
signed char
atomic_fetch_xor_explicit(atomic_schar* __obj, signed char __v,
                          memory_order __o)
{
    return atomic_fetch_xor_explicit(const_cast<volatile atomic_schar*>(__obj),
                                                                      __v, __o);
}

// atomic_uchar

struct atomic_uchar;

bool atomic_is_lock_free(const volatile atomic_uchar*);
bool atomic_is_lock_free(const atomic_uchar*);
void atomic_init(volatile atomic_uchar*, unsigned char);
void atomic_init(atomic_uchar*, unsigned char);
void atomic_store(volatile atomic_uchar*, unsigned char);
void atomic_store(atomic_uchar*, unsigned char);
void atomic_store_explicit(volatile atomic_uchar*, unsigned char, memory_order);
void atomic_store_explicit(atomic_uchar*, unsigned char, memory_order);
unsigned char atomic_load(const volatile atomic_uchar*);
unsigned char atomic_load(const atomic_uchar*);
unsigned char atomic_load_explicit(const volatile atomic_uchar*, memory_order);
unsigned char atomic_load_explicit(const atomic_uchar*, memory_order);
unsigned char atomic_exchange(volatile atomic_uchar*, unsigned char);
unsigned char atomic_exchange(atomic_uchar*, unsigned char);
unsigned char atomic_exchange_explicit(volatile atomic_uchar*, unsigned char,
                                     memory_order);
unsigned char atomic_exchange_explicit(atomic_uchar*, unsigned char,
                                       memory_order);
bool atomic_compare_exchange_weak(volatile atomic_uchar*, unsigned char*,
                                  unsigned char);
bool atomic_compare_exchange_weak(atomic_uchar*, unsigned char*, unsigned char);
bool atomic_compare_exchange_strong(volatile atomic_uchar*, unsigned char*,
                                    unsigned char);
bool atomic_compare_exchange_strong(atomic_uchar*, unsigned char*,
                                    unsigned char);
bool atomic_compare_exchange_weak_explicit(volatile atomic_uchar*,
                                           unsigned char*, unsigned char,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_uchar*, unsigned char*,
                                           unsigned char, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_uchar*,
                                             unsigned char*, unsigned char,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_uchar*, unsigned char*,
                                             unsigned char, memory_order,
                                             memory_order);
unsigned char atomic_fetch_add(volatile atomic_uchar*, unsigned char);
unsigned char atomic_fetch_add(atomic_uchar*, unsigned char);
unsigned char atomic_fetch_add_explicit(volatile atomic_uchar*, unsigned char,
                                        memory_order);
unsigned char atomic_fetch_add_explicit(atomic_uchar*, unsigned char,
                                        memory_order);
unsigned char atomic_fetch_sub(volatile atomic_uchar*, unsigned char);
unsigned char atomic_fetch_sub(atomic_uchar*, unsigned char);
unsigned char atomic_fetch_sub_explicit(volatile atomic_uchar*, unsigned char,
                                      memory_order);
unsigned char atomic_fetch_sub_explicit(atomic_uchar*, unsigned char,
                                        memory_order);
unsigned char atomic_fetch_and(volatile atomic_uchar*, unsigned char);
unsigned char atomic_fetch_and(atomic_uchar*, unsigned char);
unsigned char atomic_fetch_and_explicit(volatile atomic_uchar*, unsigned char,
                                        memory_order);
unsigned char atomic_fetch_and_explicit(atomic_uchar*, unsigned char,
                                        memory_order);
unsigned char atomic_fetch_or(volatile atomic_uchar*, unsigned char);
unsigned char atomic_fetch_or(atomic_uchar*, unsigned char);
unsigned char atomic_fetch_or_explicit(volatile atomic_uchar*, unsigned char,
                                       memory_order);
unsigned char atomic_fetch_or_explicit(atomic_uchar*, unsigned char,
                                       memory_order);
unsigned char atomic_fetch_xor(volatile atomic_uchar*, unsigned char);
unsigned char atomic_fetch_xor(atomic_uchar*, unsigned char);
unsigned char atomic_fetch_xor_explicit(volatile atomic_uchar*, unsigned char,
                                        memory_order);
unsigned char atomic_fetch_xor_explicit(atomic_uchar*, unsigned char,
                                        memory_order);

typedef struct atomic_uchar
{
    unsigned char __v_;

    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const volatile
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    void store(unsigned char __v,
               memory_order __o = memory_order_seq_cst) volatile
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void store(unsigned char __v, memory_order __o = memory_order_seq_cst)
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char load(memory_order __o = memory_order_seq_cst) const volatile
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char load(memory_order __o = memory_order_seq_cst) const
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    operator unsigned char() const volatile
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    operator unsigned char() const
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char exchange(unsigned char __v,
                           memory_order __o = memory_order_seq_cst) volatile
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char exchange(unsigned char __v,
                           memory_order __o = memory_order_seq_cst)
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned char& __v, unsigned char __e,
                               memory_order __s, memory_order __f) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned char& __v, unsigned char __e,
                               memory_order __s, memory_order __f)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned char& __v, unsigned char __e,
                                 memory_order __s, memory_order __f) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned char& __v, unsigned char __e,
                                 memory_order __s, memory_order __f)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned char& __v, unsigned char __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned char& __v, unsigned char __e,
                               memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned char& __v, unsigned char __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned char& __v, unsigned char __e,
                                 memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char fetch_add(unsigned char __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char fetch_add(unsigned char __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char fetch_sub(unsigned char __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char fetch_sub(unsigned char __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char fetch_and(unsigned char __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char fetch_and(unsigned char __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char fetch_or(unsigned char __v,
                           memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char fetch_or(unsigned char __v,
                           memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char fetch_xor(unsigned char __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_xor_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char fetch_xor(unsigned char __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_xor_explicit(this, __v, __o);}
#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_uchar() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_uchar() {}
#endif
    _LIBCPP_INLINE_VISIBILITY
    /*constexpr*/ atomic_uchar(unsigned char __v)
        : __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_uchar(const atomic_uchar&) = delete;
    atomic_uchar& operator=(const atomic_uchar&) = delete;
    atomic_uchar& operator=(const atomic_uchar&) volatile = delete;
#else
private:
    atomic_uchar(const atomic_uchar&);
    atomic_uchar& operator=(const atomic_uchar&);
    atomic_uchar& operator=(const atomic_uchar&) volatile;
public:
#endif
    _LIBCPP_INLINE_VISIBILITY
    unsigned char operator=(unsigned char __v) volatile
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char operator=(unsigned char __v)
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    unsigned char operator++(int) volatile
        {typedef unsigned char type; return fetch_add(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    char operator++(int)
        {typedef unsigned char type; return fetch_add(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    char operator--(int) volatile
        {typedef unsigned char type; return fetch_sub(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    char operator--(int)
        {typedef unsigned char type; return fetch_sub(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    char operator++() volatile
        {typedef unsigned char type; return type(fetch_add(type(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    char operator++()
        {typedef unsigned char type; return type(fetch_add(type(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    char operator--() volatile
        {typedef unsigned char type; return type(fetch_sub(type(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    char operator--()
        {typedef unsigned char type; return type(fetch_sub(type(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    char operator+=(char __v) volatile
        {typedef unsigned char type; return type(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator+=(char __v)
        {typedef unsigned char type; return type(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator-=(char __v) volatile
        {typedef unsigned char type; return type(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator-=(char __v)
        {typedef unsigned char type; return type(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator&=(char __v) volatile
        {typedef unsigned char type; return type(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator&=(char __v)
        {typedef unsigned char type; return type(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator|=(char __v) volatile
        {typedef unsigned char type; return type(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator|=(char __v)
        {typedef unsigned char type; return type(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator^=(char __v) volatile
        {typedef unsigned char type; return type(fetch_xor(__v) ^ __v);}
    _LIBCPP_INLINE_VISIBILITY
    char operator^=(char __v)
        {typedef unsigned char type; return type(fetch_xor(__v) ^ __v);}
} atomic_uchar;

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const volatile atomic_uchar*)
{
    typedef unsigned char type;
    return __atomic_is_lock_free(type);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const atomic_uchar* __obj)
{
    return atomic_is_lock_free(const_cast<volatile atomic_uchar*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(volatile atomic_uchar* __obj, unsigned char __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(atomic_uchar* __obj, unsigned char __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(volatile atomic_uchar* __obj, unsigned char __desr)
{
    __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(atomic_uchar* __obj, unsigned char __desr)
{
    atomic_store(const_cast<volatile atomic_uchar*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(volatile atomic_uchar* __obj, unsigned char __desr,
                      memory_order __o)
{
    __atomic_store(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(atomic_uchar* __obj, unsigned char __desr,
                      memory_order __o)
{
    atomic_store_explicit(const_cast<volatile atomic_uchar*>(__obj), __desr,
                                                                           __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_load(const volatile atomic_uchar* __obj)
{
    return __atomic_load(&__obj->__v_, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_load(const atomic_uchar* __obj)
{
    return atomic_load(const_cast<const volatile atomic_uchar*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_load_explicit(const volatile atomic_uchar* __obj, memory_order __o)
{
    return __atomic_load(&__obj->__v_, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_load_explicit(const atomic_uchar* __obj, memory_order __o)
{
    return atomic_load_explicit(const_cast<const volatile atomic_uchar*>
                                                                  (__obj), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_exchange(volatile atomic_uchar* __obj, unsigned char __desr)
{
    return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_exchange(atomic_uchar* __obj, unsigned char __desr)
{
    return atomic_exchange(const_cast<volatile atomic_uchar*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_exchange_explicit(volatile atomic_uchar* __obj, unsigned char __desr,
                         memory_order __o)
{
    return __atomic_exchange(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_exchange_explicit(atomic_uchar* __obj, unsigned char __desr,
                         memory_order __o)
{
    return atomic_exchange_explicit(const_cast<volatile atomic_uchar*>
                                                          (__obj), __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(volatile atomic_uchar* __obj, unsigned char* __exp,
                             unsigned char __desr)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(atomic_uchar* __obj, unsigned char* __exp,
                             unsigned char __desr)
{
    return atomic_compare_exchange_weak(const_cast<volatile atomic_uchar*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(volatile atomic_uchar* __obj,
                               unsigned char* __exp, unsigned char __desr)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(atomic_uchar* __obj, unsigned char* __exp,
                               unsigned char __desr)
{
    return atomic_compare_exchange_strong(const_cast<volatile atomic_uchar*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(volatile atomic_uchar* __obj,
                                      unsigned char* __exp,
                                      unsigned char __desr, memory_order __s,
                                      memory_order __f)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(atomic_uchar* __obj, unsigned char* __exp,
                                      unsigned char __desr, memory_order __s,
                                      memory_order __f)
{
    return atomic_compare_exchange_weak_explicit(
             const_cast<volatile atomic_uchar*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(volatile atomic_uchar* __obj,
                                        unsigned char* __exp,
                                        unsigned char __desr, memory_order __s,
                                        memory_order __f)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(atomic_uchar* __obj,
                                        unsigned char* __exp,
                                        unsigned char __desr, memory_order __s,
                                        memory_order __f)
{
    return atomic_compare_exchange_strong_explicit(
             const_cast<volatile atomic_uchar*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_add(volatile atomic_uchar* __obj, unsigned char __v)
{
    return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_add(atomic_uchar* __obj, unsigned char __v)
{
    return atomic_fetch_add(const_cast<volatile atomic_uchar*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_add_explicit(volatile atomic_uchar* __obj, unsigned char __v,
                          memory_order __o)
{
    return __atomic_fetch_add(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_add_explicit(atomic_uchar* __obj, unsigned char __v,
                          memory_order __o)
{
    return atomic_fetch_add_explicit(const_cast<volatile atomic_uchar*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_sub(volatile atomic_uchar* __obj, unsigned char __v)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_sub(atomic_uchar* __obj, unsigned char __v)
{
    return atomic_fetch_sub(const_cast<volatile atomic_uchar*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_sub_explicit(volatile atomic_uchar* __obj, unsigned char __v,
                          memory_order __o)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_sub_explicit(atomic_uchar* __obj, unsigned char __v,
                          memory_order __o)
{
    return atomic_fetch_sub_explicit(const_cast<volatile atomic_uchar*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_and(volatile atomic_uchar* __obj, unsigned char __v)
{
    return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_and(atomic_uchar* __obj, unsigned char __v)
{
    return atomic_fetch_and(const_cast<volatile atomic_uchar*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_and_explicit(volatile atomic_uchar* __obj, unsigned char __v,
                          memory_order __o)
{
    return __atomic_fetch_and(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_and_explicit(atomic_uchar* __obj, unsigned char __v,
                          memory_order __o)
{
    return atomic_fetch_and_explicit(const_cast<volatile atomic_uchar*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_or(volatile atomic_uchar* __obj, unsigned char __v)
{
    return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_or(atomic_uchar* __obj, unsigned char __v)
{
    return atomic_fetch_or(const_cast<volatile atomic_uchar*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_or_explicit(volatile atomic_uchar* __obj, unsigned char __v,
                         memory_order __o)
{
    return __atomic_fetch_or(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_or_explicit(atomic_uchar* __obj, unsigned char __v,
                         memory_order __o)
{
    return atomic_fetch_or_explicit(const_cast<volatile atomic_uchar*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_xor(volatile atomic_uchar* __obj, unsigned char __v)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_xor(atomic_uchar* __obj, unsigned char __v)
{
    return atomic_fetch_xor(const_cast<volatile atomic_uchar*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_xor_explicit(volatile atomic_uchar* __obj, unsigned char __v,
                          memory_order __o)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned char
atomic_fetch_xor_explicit(atomic_uchar* __obj, unsigned char __v,
                          memory_order __o)
{
    return atomic_fetch_xor_explicit(const_cast<volatile atomic_uchar*>(__obj),
                                                                      __v, __o);
}

// atomic_short

struct atomic_short;

bool atomic_is_lock_free(const volatile atomic_short*);
bool atomic_is_lock_free(const atomic_short*);
void atomic_init(volatile atomic_short*, short);
void atomic_init(atomic_short*, short);
void atomic_store(volatile atomic_short*, short);
void atomic_store(atomic_short*, short);
void atomic_store_explicit(volatile atomic_short*, short, memory_order);
void atomic_store_explicit(atomic_short*, short, memory_order);
short atomic_load(const volatile atomic_short*);
short atomic_load(const atomic_short*);
short atomic_load_explicit(const volatile atomic_short*, memory_order);
short atomic_load_explicit(const atomic_short*, memory_order);
short atomic_exchange(volatile atomic_short*, short);
short atomic_exchange(atomic_short*, short);
short atomic_exchange_explicit(volatile atomic_short*, short, memory_order);
short atomic_exchange_explicit(atomic_short*, short, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_short*, short*, short);
bool atomic_compare_exchange_weak(atomic_short*, short*, short);
bool atomic_compare_exchange_strong(volatile atomic_short*, short*, short);
bool atomic_compare_exchange_strong(atomic_short*, short*, short);
bool atomic_compare_exchange_weak_explicit(volatile atomic_short*, short*,
                                           short, memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_short*, short*, short,
                                           memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_short*, short*,
                                             short, memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_short*, short*, short,
                                             memory_order, memory_order);
short atomic_fetch_add(volatile atomic_short*, short);
short atomic_fetch_add(atomic_short*, short);
short atomic_fetch_add_explicit(volatile atomic_short*, short, memory_order);
short atomic_fetch_add_explicit(atomic_short*, short, memory_order);
short atomic_fetch_sub(volatile atomic_short*, short);
short atomic_fetch_sub(atomic_short*, short);
short atomic_fetch_sub_explicit(volatile atomic_short*, short, memory_order);
short atomic_fetch_sub_explicit(atomic_short*, short, memory_order);
short atomic_fetch_and(volatile atomic_short*, short);
short atomic_fetch_and(atomic_short*, short);
short atomic_fetch_and_explicit(volatile atomic_short*, short, memory_order);
short atomic_fetch_and_explicit(atomic_short*, short, memory_order);
short atomic_fetch_or(volatile atomic_short*, short);
short atomic_fetch_or(atomic_short*, short);
short atomic_fetch_or_explicit(volatile atomic_short*, short, memory_order);
short atomic_fetch_or_explicit(atomic_short*, short, memory_order);
short atomic_fetch_xor(volatile atomic_short*, short);
short atomic_fetch_xor(atomic_short*, short);
short atomic_fetch_xor_explicit(volatile atomic_short*, short, memory_order);
short atomic_fetch_xor_explicit(atomic_short*, short, memory_order);

typedef struct atomic_short
{
    short __v_;

    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const volatile
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    void store(short __v, memory_order __o = memory_order_seq_cst) volatile
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void store(short __v, memory_order __o = memory_order_seq_cst)
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    short load(memory_order __o = memory_order_seq_cst) const volatile
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    short load(memory_order __o = memory_order_seq_cst) const
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    operator short() const volatile
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    operator short() const
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    short exchange(short __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    short exchange(short __v, memory_order __o = memory_order_seq_cst)
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(short& __v, short __e, memory_order __s,
                               memory_order __f) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(short& __v, short __e, memory_order __s,
                               memory_order __f)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(short& __v, short __e, memory_order __s,
                                 memory_order __f) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(short& __v, short __e, memory_order __s,
                                 memory_order __f)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(short& __v, short __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(short& __v, short __e,
                               memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(short& __v, short __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(short& __v, short __e,
                                 memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    short fetch_add(short __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    short fetch_add(short __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    short fetch_sub(short __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    short fetch_sub(short __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    short fetch_and(short __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    short fetch_and(short __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    short fetch_or(short __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    short fetch_or(short __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    short fetch_xor(short __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_xor_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    short fetch_xor(short __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_xor_explicit(this, __v, __o);}
#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_short() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_short() {}
#endif
    _LIBCPP_INLINE_VISIBILITY
    /*constexpr*/ atomic_short(short __v)
        : __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_short(const atomic_short&) = delete;
    atomic_short& operator=(const atomic_short&) = delete;
    atomic_short& operator=(const atomic_short&) volatile = delete;
#else
private:
    atomic_short(const atomic_short&);
    atomic_short& operator=(const atomic_short&);
    atomic_short& operator=(const atomic_short&) volatile;
public:
#endif
    _LIBCPP_INLINE_VISIBILITY
    short operator=(short __v) volatile
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    short operator=(short __v)
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    short operator++(int) volatile
        {return fetch_add(short(1));}
    _LIBCPP_INLINE_VISIBILITY
    short operator++(int)
        {return fetch_add(short(1));}
    _LIBCPP_INLINE_VISIBILITY
    short operator--(int) volatile
        {return fetch_sub(short(1));}
    _LIBCPP_INLINE_VISIBILITY
    short operator--(int)
        {return fetch_sub(short(1));}
    _LIBCPP_INLINE_VISIBILITY
    short operator++() volatile
        {return short(fetch_add(short(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    short operator++()
        {return short(fetch_add(short(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    short operator--() volatile
        {return short(fetch_sub(short(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    short operator--()
        {return short(fetch_sub(short(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    short operator+=(short __v) volatile
        {return short(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator+=(short __v)
        {return short(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator-=(short __v) volatile
        {return short(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator-=(short __v)
        {return short(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator&=(short __v) volatile
        {return short(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator&=(short __v)
        {return short(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator|=(short __v) volatile
        {return short(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator|=(short __v)
        {return short(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator^=(short __v) volatile
        {return short(fetch_xor(__v) ^ __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator^=(short __v)
        {return short(fetch_xor(__v) ^ __v);}
} atomic_short;

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const volatile atomic_short*)
{
    typedef short type;
    return __atomic_is_lock_free(type);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const atomic_short* __obj)
{
    return atomic_is_lock_free(const_cast<volatile atomic_short*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(volatile atomic_short* __obj, short __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(atomic_short* __obj, short __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(volatile atomic_short* __obj, short __desr)
{
    __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(atomic_short* __obj, short __desr)
{
    atomic_store(const_cast<volatile atomic_short*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(volatile atomic_short* __obj, short __desr,
                      memory_order __o)
{
    __atomic_store(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(atomic_short* __obj, short __desr, memory_order __o)
{
    atomic_store_explicit(const_cast<volatile atomic_short*>(__obj), __desr,
                                                                           __o);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_load(const volatile atomic_short* __obj)
{
    return __atomic_load(&__obj->__v_, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_load(const atomic_short* __obj)
{
    return atomic_load(const_cast<const volatile atomic_short*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_load_explicit(const volatile atomic_short* __obj, memory_order __o)
{
    return __atomic_load(&__obj->__v_, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_load_explicit(const atomic_short* __obj, memory_order __o)
{
    return atomic_load_explicit(const_cast<const volatile atomic_short*>
                                                                  (__obj), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_exchange(volatile atomic_short* __obj, short __desr)
{
    return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_exchange(atomic_short* __obj, short __desr)
{
    return atomic_exchange(const_cast<volatile atomic_short*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_exchange_explicit(volatile atomic_short* __obj, short __desr,
                         memory_order __o)
{
    return __atomic_exchange(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_exchange_explicit(atomic_short* __obj, short __desr, memory_order __o)
{
    return atomic_exchange_explicit(const_cast<volatile atomic_short*>
                                                          (__obj), __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(volatile atomic_short* __obj, short* __exp,
                             short __desr)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(atomic_short* __obj, short* __exp, short __desr)
{
    return atomic_compare_exchange_weak(const_cast<volatile atomic_short*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(volatile atomic_short* __obj, short* __exp,
                               short __desr)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(atomic_short* __obj, short* __exp, short __desr)
{
    return atomic_compare_exchange_strong(const_cast<volatile atomic_short*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(volatile atomic_short* __obj,
                                      short* __exp, short __desr,
                                      memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(atomic_short* __obj, short* __exp,
                                      short __desr, memory_order __s,
                                      memory_order __f)
{
    return atomic_compare_exchange_weak_explicit(
             const_cast<volatile atomic_short*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(volatile atomic_short* __obj,
                                        short* __exp, short __desr,
                                        memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(atomic_short* __obj, short* __exp,
                                        short __desr, memory_order __s,
                                        memory_order __f)
{
    return atomic_compare_exchange_strong_explicit(
             const_cast<volatile atomic_short*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_add(volatile atomic_short* __obj, short __v)
{
    return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_add(atomic_short* __obj, short __v)
{
    return atomic_fetch_add(const_cast<volatile atomic_short*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_add_explicit(volatile atomic_short* __obj, short __v,
                          memory_order __o)
{
    return __atomic_fetch_add(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_add_explicit(atomic_short* __obj, short __v, memory_order __o)
{
    return atomic_fetch_add_explicit(const_cast<volatile atomic_short*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_sub(volatile atomic_short* __obj, short __v)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_sub(atomic_short* __obj, short __v)
{
    return atomic_fetch_sub(const_cast<volatile atomic_short*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_sub_explicit(volatile atomic_short* __obj, short __v,
                          memory_order __o)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_sub_explicit(atomic_short* __obj, short __v, memory_order __o)
{
    return atomic_fetch_sub_explicit(const_cast<volatile atomic_short*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_and(volatile atomic_short* __obj, short __v)
{
    return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_and(atomic_short* __obj, short __v)
{
    return atomic_fetch_and(const_cast<volatile atomic_short*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_and_explicit(volatile atomic_short* __obj, short __v,
                          memory_order __o)
{
    return __atomic_fetch_and(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_and_explicit(atomic_short* __obj, short __v, memory_order __o)
{
    return atomic_fetch_and_explicit(const_cast<volatile atomic_short*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_or(volatile atomic_short* __obj, short __v)
{
    return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_or(atomic_short* __obj, short __v)
{
    return atomic_fetch_or(const_cast<volatile atomic_short*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_or_explicit(volatile atomic_short* __obj, short __v,
                         memory_order __o)
{
    return __atomic_fetch_or(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_or_explicit(atomic_short* __obj, short __v, memory_order __o)
{
    return atomic_fetch_or_explicit(const_cast<volatile atomic_short*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_xor(volatile atomic_short* __obj, short __v)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_xor(atomic_short* __obj, short __v)
{
    return atomic_fetch_xor(const_cast<volatile atomic_short*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_xor_explicit(volatile atomic_short* __obj, short __v,
                          memory_order __o)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
short
atomic_fetch_xor_explicit(atomic_short* __obj, short __v, memory_order __o)
{
    return atomic_fetch_xor_explicit(const_cast<volatile atomic_short*>(__obj),
                                                                      __v, __o);
}

// atomic_ushort

struct atomic_ushort;

bool atomic_is_lock_free(const volatile atomic_ushort*);
bool atomic_is_lock_free(const atomic_ushort*);
void atomic_init(volatile atomic_ushort*, unsigned short);
void atomic_init(atomic_ushort*, unsigned short);
void atomic_store(volatile atomic_ushort*, unsigned short);
void atomic_store(atomic_ushort*, unsigned short);
void atomic_store_explicit(volatile atomic_ushort*, unsigned short,
                           memory_order);
void atomic_store_explicit(atomic_ushort*, unsigned short, memory_order);
unsigned short atomic_load(const volatile atomic_ushort*);
unsigned short atomic_load(const atomic_ushort*);
unsigned short atomic_load_explicit(const volatile atomic_ushort*,
                                    memory_order);
unsigned short atomic_load_explicit(const atomic_ushort*, memory_order);
unsigned short atomic_exchange(volatile atomic_ushort*, unsigned short);
unsigned short atomic_exchange(atomic_ushort*, unsigned short);
unsigned short atomic_exchange_explicit(volatile atomic_ushort*, unsigned short,
                                        memory_order);
unsigned short atomic_exchange_explicit(atomic_ushort*, unsigned short,
                                        memory_order);
bool atomic_compare_exchange_weak(volatile atomic_ushort*, unsigned short*,
                                  unsigned short);
bool atomic_compare_exchange_weak(atomic_ushort*, unsigned short*,
                                  unsigned short);
bool atomic_compare_exchange_strong(volatile atomic_ushort*, unsigned short*,
                                    unsigned short);
bool atomic_compare_exchange_strong(atomic_ushort*, unsigned short*,
                                    unsigned short);
bool atomic_compare_exchange_weak_explicit(volatile atomic_ushort*,
                                           unsigned short*, unsigned short,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_ushort*, unsigned short*,
                                           unsigned short, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_ushort*,
                                             unsigned short*, unsigned short,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_ushort*, unsigned short*,
                                             unsigned short, memory_order,
                                             memory_order);
unsigned short atomic_fetch_add(volatile atomic_ushort*, unsigned short);
unsigned short atomic_fetch_add(atomic_ushort*, unsigned short);
unsigned short atomic_fetch_add_explicit(volatile atomic_ushort*,
                                         unsigned short, memory_order);
unsigned short atomic_fetch_add_explicit(atomic_ushort*, unsigned short,
                                         memory_order);
unsigned short atomic_fetch_sub(volatile atomic_ushort*, unsigned short);
unsigned short atomic_fetch_sub(atomic_ushort*, unsigned short);
unsigned short atomic_fetch_sub_explicit(volatile atomic_ushort*,
                                         unsigned short, memory_order);
unsigned short atomic_fetch_sub_explicit(atomic_ushort*, unsigned short,
                                         memory_order);
unsigned short atomic_fetch_and(volatile atomic_ushort*, unsigned short);
unsigned short atomic_fetch_and(atomic_ushort*, unsigned short);
unsigned short atomic_fetch_and_explicit(volatile atomic_ushort*,
                                         unsigned short, memory_order);
unsigned short atomic_fetch_and_explicit(atomic_ushort*, unsigned short,
                                         memory_order);
unsigned short atomic_fetch_or(volatile atomic_ushort*, unsigned short);
unsigned short atomic_fetch_or(atomic_ushort*, unsigned short);
unsigned short atomic_fetch_or_explicit(volatile atomic_ushort*, unsigned short,
                                        memory_order);
unsigned short atomic_fetch_or_explicit(atomic_ushort*, unsigned short,
                                        memory_order);
unsigned short atomic_fetch_xor(volatile atomic_ushort*, unsigned short);
unsigned short atomic_fetch_xor(atomic_ushort*, unsigned short);
unsigned short atomic_fetch_xor_explicit(volatile atomic_ushort*,
                                         unsigned short, memory_order);
unsigned short atomic_fetch_xor_explicit(atomic_ushort*, unsigned short,
                                         memory_order);

typedef struct atomic_ushort
{
    unsigned short __v_;

    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const volatile
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    void store(unsigned short __v,
               memory_order __o = memory_order_seq_cst) volatile
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void store(unsigned short __v, memory_order __o = memory_order_seq_cst)
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short load(memory_order __o = memory_order_seq_cst) const volatile
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short load(memory_order __o = memory_order_seq_cst) const
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    operator unsigned short() const volatile
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    operator unsigned short() const
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short exchange(unsigned short __v,
                           memory_order __o = memory_order_seq_cst) volatile
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short exchange(unsigned short __v,
                           memory_order __o = memory_order_seq_cst)
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned short& __v, unsigned short __e,
                               memory_order __s, memory_order __f) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned short& __v, unsigned short __e,
                               memory_order __s, memory_order __f)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned short& __v, unsigned short __e,
                                 memory_order __s, memory_order __f) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned short& __v, unsigned short __e,
                                 memory_order __s, memory_order __f)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned short& __v, unsigned short __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned short& __v, unsigned short __e,
                               memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned short& __v, unsigned short __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned short& __v, unsigned short __e,
                                 memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short fetch_add(unsigned short __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short fetch_add(unsigned short __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short fetch_sub(unsigned short __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short fetch_sub(unsigned short __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short fetch_and(unsigned short __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short fetch_and(unsigned short __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short fetch_or(unsigned short __v,
                           memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short fetch_or(unsigned short __v,
                           memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short fetch_xor(unsigned short __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_xor_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short fetch_xor(unsigned short __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_xor_explicit(this, __v, __o);}
#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_ushort() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_ushort() {}
#endif
    _LIBCPP_INLINE_VISIBILITY
    /*constexpr*/ atomic_ushort(unsigned short __v)
        : __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_ushort(const atomic_ushort&) = delete;
    atomic_ushort& operator=(const atomic_ushort&) = delete;
    atomic_ushort& operator=(const atomic_ushort&) volatile = delete;
#else
private:
    atomic_ushort(const atomic_ushort&);
    atomic_ushort& operator=(const atomic_ushort&);
    atomic_ushort& operator=(const atomic_ushort&) volatile;
public:
#endif
    _LIBCPP_INLINE_VISIBILITY
    unsigned short operator=(unsigned short __v) volatile
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short operator=(unsigned short __v)
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    unsigned short operator++(int) volatile
        {typedef unsigned short type; return fetch_add(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    short operator++(int)
        {typedef unsigned short type; return fetch_add(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    short operator--(int) volatile
        {typedef unsigned short type; return fetch_sub(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    short operator--(int)
        {typedef unsigned short type; return fetch_sub(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    short operator++() volatile
        {typedef unsigned short type; return type(fetch_add(type(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    short operator++()
        {typedef unsigned short type; return type(fetch_add(type(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    short operator--() volatile
        {typedef unsigned short type; return type(fetch_sub(type(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    short operator--()
        {typedef unsigned short type; return type(fetch_sub(type(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    short operator+=(short __v) volatile
        {typedef unsigned short type; return type(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator+=(short __v)
        {typedef unsigned short type; return type(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator-=(short __v) volatile
        {typedef unsigned short type; return type(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator-=(short __v)
        {typedef unsigned short type; return type(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator&=(short __v) volatile
        {typedef unsigned short type; return type(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator&=(short __v)
        {typedef unsigned short type; return type(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator|=(short __v) volatile
        {typedef unsigned short type; return type(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator|=(short __v)
        {typedef unsigned short type; return type(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator^=(short __v) volatile
        {typedef unsigned short type; return type(fetch_xor(__v) ^ __v);}
    _LIBCPP_INLINE_VISIBILITY
    short operator^=(short __v)
        {typedef unsigned short type; return type(fetch_xor(__v) ^ __v);}
} atomic_ushort;

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const volatile atomic_ushort*)
{
    typedef unsigned short type;
    return __atomic_is_lock_free(type);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const atomic_ushort* __obj)
{
    return atomic_is_lock_free(const_cast<volatile atomic_ushort*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(volatile atomic_ushort* __obj, unsigned short __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(atomic_ushort* __obj, unsigned short __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(volatile atomic_ushort* __obj, unsigned short __desr)
{
    __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(atomic_ushort* __obj, unsigned short __desr)
{
    atomic_store(const_cast<volatile atomic_ushort*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(volatile atomic_ushort* __obj, unsigned short __desr,
                      memory_order __o)
{
    __atomic_store(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(atomic_ushort* __obj, unsigned short __desr,
                      memory_order __o)
{
    atomic_store_explicit(const_cast<volatile atomic_ushort*>(__obj), __desr,
                                                                           __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_load(const volatile atomic_ushort* __obj)
{
    return __atomic_load(&__obj->__v_, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_load(const atomic_ushort* __obj)
{
    return atomic_load(const_cast<const volatile atomic_ushort*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_load_explicit(const volatile atomic_ushort* __obj, memory_order __o)
{
    return __atomic_load(&__obj->__v_, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_load_explicit(const atomic_ushort* __obj, memory_order __o)
{
    return atomic_load_explicit(const_cast<const volatile atomic_ushort*>
                                                                  (__obj), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_exchange(volatile atomic_ushort* __obj, unsigned short __desr)
{
    return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_exchange(atomic_ushort* __obj, unsigned short __desr)
{
    return atomic_exchange(const_cast<volatile atomic_ushort*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_exchange_explicit(volatile atomic_ushort* __obj, unsigned short __desr,
                         memory_order __o)
{
    return __atomic_exchange(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_exchange_explicit(atomic_ushort* __obj, unsigned short __desr,
                         memory_order __o)
{
    return atomic_exchange_explicit(const_cast<volatile atomic_ushort*>
                                                          (__obj), __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(volatile atomic_ushort* __obj,
                             unsigned short* __exp, unsigned short __desr)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(atomic_ushort* __obj, unsigned short* __exp,
                             unsigned short __desr)
{
    return atomic_compare_exchange_weak(const_cast<volatile atomic_ushort*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(volatile atomic_ushort* __obj,
                               unsigned short* __exp, unsigned short __desr)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(atomic_ushort* __obj, unsigned short* __exp,
                               unsigned short __desr)
{
    return atomic_compare_exchange_strong(const_cast<volatile atomic_ushort*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(volatile atomic_ushort* __obj,
                                      unsigned short* __exp,
                                      unsigned short __desr, memory_order __s,
                                      memory_order __f)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(atomic_ushort* __obj,
                                      unsigned short* __exp,
                                      unsigned short __desr, memory_order __s,
                                      memory_order __f)
{
    return atomic_compare_exchange_weak_explicit(
             const_cast<volatile atomic_ushort*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(volatile atomic_ushort* __obj,
                                        unsigned short* __exp,
                                        unsigned short __desr, memory_order __s,
                                        memory_order __f)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(atomic_ushort* __obj,
                                        unsigned short* __exp,
                                        unsigned short __desr, memory_order __s,
                                        memory_order __f)
{
    return atomic_compare_exchange_strong_explicit(
             const_cast<volatile atomic_ushort*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_add(volatile atomic_ushort* __obj, unsigned short __v)
{
    return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_add(atomic_ushort* __obj, unsigned short __v)
{
    return atomic_fetch_add(const_cast<volatile atomic_ushort*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_add_explicit(volatile atomic_ushort* __obj, unsigned short __v,
                          memory_order __o)
{
    return __atomic_fetch_add(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_add_explicit(atomic_ushort* __obj, unsigned short __v,
                          memory_order __o)
{
    return atomic_fetch_add_explicit(const_cast<volatile atomic_ushort*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_sub(volatile atomic_ushort* __obj, unsigned short __v)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_sub(atomic_ushort* __obj, unsigned short __v)
{
    return atomic_fetch_sub(const_cast<volatile atomic_ushort*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_sub_explicit(volatile atomic_ushort* __obj, unsigned short __v,
                          memory_order __o)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_sub_explicit(atomic_ushort* __obj, unsigned short __v,
                          memory_order __o)
{
    return atomic_fetch_sub_explicit(const_cast<volatile atomic_ushort*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_and(volatile atomic_ushort* __obj, unsigned short __v)
{
    return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_and(atomic_ushort* __obj, unsigned short __v)
{
    return atomic_fetch_and(const_cast<volatile atomic_ushort*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_and_explicit(volatile atomic_ushort* __obj, unsigned short __v,
                          memory_order __o)
{
    return __atomic_fetch_and(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_and_explicit(atomic_ushort* __obj, unsigned short __v,
                          memory_order __o)
{
    return atomic_fetch_and_explicit(const_cast<volatile atomic_ushort*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_or(volatile atomic_ushort* __obj, unsigned short __v)
{
    return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_or(atomic_ushort* __obj, unsigned short __v)
{
    return atomic_fetch_or(const_cast<volatile atomic_ushort*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_or_explicit(volatile atomic_ushort* __obj, unsigned short __v,
                         memory_order __o)
{
    return __atomic_fetch_or(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_or_explicit(atomic_ushort* __obj, unsigned short __v,
                         memory_order __o)
{
    return atomic_fetch_or_explicit(const_cast<volatile atomic_ushort*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_xor(volatile atomic_ushort* __obj, unsigned short __v)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_xor(atomic_ushort* __obj, unsigned short __v)
{
    return atomic_fetch_xor(const_cast<volatile atomic_ushort*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_xor_explicit(volatile atomic_ushort* __obj, unsigned short __v,
                          memory_order __o)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned short
atomic_fetch_xor_explicit(atomic_ushort* __obj, unsigned short __v,
                          memory_order __o)
{
    return atomic_fetch_xor_explicit(const_cast<volatile atomic_ushort*>(__obj),
                                                                      __v, __o);
}

// atomic_int

struct atomic_int;

bool atomic_is_lock_free(const volatile atomic_int*);
bool atomic_is_lock_free(const atomic_int*);
void atomic_init(volatile atomic_int*, int);
void atomic_init(atomic_int*, int);
void atomic_store(volatile atomic_int*, int);
void atomic_store(atomic_int*, int);
void atomic_store_explicit(volatile atomic_int*, int, memory_order);
void atomic_store_explicit(atomic_int*, int, memory_order);
int atomic_load(const volatile atomic_int*);
int atomic_load(const atomic_int*);
int atomic_load_explicit(const volatile atomic_int*, memory_order);
int atomic_load_explicit(const atomic_int*, memory_order);
int atomic_exchange(volatile atomic_int*, int);
int atomic_exchange(atomic_int*, int);
int atomic_exchange_explicit(volatile atomic_int*, int, memory_order);
int atomic_exchange_explicit(atomic_int*, int, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_int*, int*, int);
bool atomic_compare_exchange_weak(atomic_int*, int*, int);
bool atomic_compare_exchange_strong(volatile atomic_int*, int*, int);
bool atomic_compare_exchange_strong(atomic_int*, int*, int);
bool atomic_compare_exchange_weak_explicit(volatile atomic_int*, int*, int,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_int*, int*, int,
                                           memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_int*, int*, int,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_int*, int*, int,
                                             memory_order, memory_order);
int atomic_fetch_add(volatile atomic_int*, int);
int atomic_fetch_add(atomic_int*, int);
int atomic_fetch_add_explicit(volatile atomic_int*, int, memory_order);
int atomic_fetch_add_explicit(atomic_int*, int, memory_order);
int atomic_fetch_sub(volatile atomic_int*, int);
int atomic_fetch_sub(atomic_int*, int);
int atomic_fetch_sub_explicit(volatile atomic_int*, int, memory_order);
int atomic_fetch_sub_explicit(atomic_int*, int, memory_order);
int atomic_fetch_and(volatile atomic_int*, int);
int atomic_fetch_and(atomic_int*, int);
int atomic_fetch_and_explicit(volatile atomic_int*, int, memory_order);
int atomic_fetch_and_explicit(atomic_int*, int, memory_order);
int atomic_fetch_or(volatile atomic_int*, int);
int atomic_fetch_or(atomic_int*, int);
int atomic_fetch_or_explicit(volatile atomic_int*, int, memory_order);
int atomic_fetch_or_explicit(atomic_int*, int, memory_order);
int atomic_fetch_xor(volatile atomic_int*, int);
int atomic_fetch_xor(atomic_int*, int);
int atomic_fetch_xor_explicit(volatile atomic_int*, int, memory_order);
int atomic_fetch_xor_explicit(atomic_int*, int, memory_order);

typedef struct atomic_int
{
    int __v_;

    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const volatile
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    void store(int __v, memory_order __o = memory_order_seq_cst) volatile
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void store(int __v, memory_order __o = memory_order_seq_cst)
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    int load(memory_order __o = memory_order_seq_cst) const volatile
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    int load(memory_order __o = memory_order_seq_cst) const
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    operator int() const volatile
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    operator int() const
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    int exchange(int __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    int exchange(int __v, memory_order __o = memory_order_seq_cst)
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(int& __v, int __e, memory_order __s,
                               memory_order __f) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(int& __v, int __e, memory_order __s,
                               memory_order __f)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(int& __v, int __e, memory_order __s,
                                 memory_order __f) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(int& __v, int __e, memory_order __s,
                                 memory_order __f)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(int& __v, int __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(int& __v, int __e,
                               memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(int& __v, int __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(int& __v, int __e,
                                 memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    int fetch_add(int __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    int fetch_add(int __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    int fetch_sub(int __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    int fetch_sub(int __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    int fetch_and(int __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    int fetch_and(int __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    int fetch_or(int __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    int fetch_or(int __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    int fetch_xor(int __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_xor_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    int fetch_xor(int __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_xor_explicit(this, __v, __o);}
#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_int() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_int() {}
#endif
    _LIBCPP_INLINE_VISIBILITY
    /*constexpr*/ atomic_int(int __v)
        : __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_int(const atomic_int&) = delete;
    atomic_int& operator=(const atomic_int&) = delete;
    atomic_int& operator=(const atomic_int&) volatile = delete;
#else
private:
    atomic_int(const atomic_int&);
    atomic_int& operator=(const atomic_int&);
    atomic_int& operator=(const atomic_int&) volatile;
public:
#endif
    _LIBCPP_INLINE_VISIBILITY
    int operator=(int __v) volatile
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    int operator=(int __v)
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    int operator++(int) volatile
        {return fetch_add(int(1));}
    _LIBCPP_INLINE_VISIBILITY
    int operator++(int)
        {return fetch_add(int(1));}
    _LIBCPP_INLINE_VISIBILITY
    int operator--(int) volatile
        {return fetch_sub(int(1));}
    _LIBCPP_INLINE_VISIBILITY
    int operator--(int)
        {return fetch_sub(int(1));}
    _LIBCPP_INLINE_VISIBILITY
    int operator++() volatile
        {return int(fetch_add(int(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    int operator++()
        {return int(fetch_add(int(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    int operator--() volatile
        {return int(fetch_sub(int(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    int operator--()
        {return int(fetch_sub(int(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    int operator+=(int __v) volatile
        {return int(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator+=(int __v)
        {return int(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator-=(int __v) volatile
        {return int(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator-=(int __v)
        {return int(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator&=(int __v) volatile
        {return int(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator&=(int __v)
        {return int(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator|=(int __v) volatile
        {return int(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator|=(int __v)
        {return int(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator^=(int __v) volatile
        {return int(fetch_xor(__v) ^ __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator^=(int __v)
        {return int(fetch_xor(__v) ^ __v);}
} atomic_int;

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const volatile atomic_int*)
{
    typedef int type;
    return __atomic_is_lock_free(type);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const atomic_int* __obj)
{
    return atomic_is_lock_free(const_cast<volatile atomic_int*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(volatile atomic_int* __obj, int __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(atomic_int* __obj, int __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(volatile atomic_int* __obj, int __desr)
{
    __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(atomic_int* __obj, int __desr)
{
    atomic_store(const_cast<volatile atomic_int*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(volatile atomic_int* __obj, int __desr,
                      memory_order __o)
{
    __atomic_store(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(atomic_int* __obj, int __desr, memory_order __o)
{
    atomic_store_explicit(const_cast<volatile atomic_int*>(__obj), __desr,
                                                                           __o);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_load(const volatile atomic_int* __obj)
{
    return __atomic_load(&__obj->__v_, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_load(const atomic_int* __obj)
{
    return atomic_load(const_cast<const volatile atomic_int*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_load_explicit(const volatile atomic_int* __obj, memory_order __o)
{
    return __atomic_load(&__obj->__v_, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_load_explicit(const atomic_int* __obj, memory_order __o)
{
    return atomic_load_explicit(const_cast<const volatile atomic_int*>
                                                                  (__obj), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_exchange(volatile atomic_int* __obj, int __desr)
{
    return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_exchange(atomic_int* __obj, int __desr)
{
    return atomic_exchange(const_cast<volatile atomic_int*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_exchange_explicit(volatile atomic_int* __obj, int __desr,
                         memory_order __o)
{
    return __atomic_exchange(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_exchange_explicit(atomic_int* __obj, int __desr, memory_order __o)
{
    return atomic_exchange_explicit(const_cast<volatile atomic_int*>
                                                          (__obj), __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(volatile atomic_int* __obj, int* __exp,
                             int __desr)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(atomic_int* __obj, int* __exp, int __desr)
{
    return atomic_compare_exchange_weak(const_cast<volatile atomic_int*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(volatile atomic_int* __obj, int* __exp,
                               int __desr)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(atomic_int* __obj, int* __exp, int __desr)
{
    return atomic_compare_exchange_strong(const_cast<volatile atomic_int*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(volatile atomic_int* __obj, int* __exp,
                                      int __desr, memory_order __s,
                                      memory_order __f)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(atomic_int* __obj, int* __exp,
                                      int __desr, memory_order __s,
                                      memory_order __f)
{
    return atomic_compare_exchange_weak_explicit(
             const_cast<volatile atomic_int*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(volatile atomic_int* __obj,
                                        int* __exp, int __desr,
                                        memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(atomic_int* __obj, int* __exp,
                                        int __desr, memory_order __s,
                                        memory_order __f)
{
    return atomic_compare_exchange_strong_explicit(
             const_cast<volatile atomic_int*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_add(volatile atomic_int* __obj, int __v)
{
    return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_add(atomic_int* __obj, int __v)
{
    return atomic_fetch_add(const_cast<volatile atomic_int*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_add_explicit(volatile atomic_int* __obj, int __v,
                          memory_order __o)
{
    return __atomic_fetch_add(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_add_explicit(atomic_int* __obj, int __v, memory_order __o)
{
    return atomic_fetch_add_explicit(const_cast<volatile atomic_int*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_sub(volatile atomic_int* __obj, int __v)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_sub(atomic_int* __obj, int __v)
{
    return atomic_fetch_sub(const_cast<volatile atomic_int*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_sub_explicit(volatile atomic_int* __obj, int __v,
                          memory_order __o)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_sub_explicit(atomic_int* __obj, int __v, memory_order __o)
{
    return atomic_fetch_sub_explicit(const_cast<volatile atomic_int*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_and(volatile atomic_int* __obj, int __v)
{
    return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_and(atomic_int* __obj, int __v)
{
    return atomic_fetch_and(const_cast<volatile atomic_int*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_and_explicit(volatile atomic_int* __obj, int __v,
                          memory_order __o)
{
    return __atomic_fetch_and(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_and_explicit(atomic_int* __obj, int __v, memory_order __o)
{
    return atomic_fetch_and_explicit(const_cast<volatile atomic_int*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_or(volatile atomic_int* __obj, int __v)
{
    return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_or(atomic_int* __obj, int __v)
{
    return atomic_fetch_or(const_cast<volatile atomic_int*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_or_explicit(volatile atomic_int* __obj, int __v,
                         memory_order __o)
{
    return __atomic_fetch_or(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_or_explicit(atomic_int* __obj, int __v, memory_order __o)
{
    return atomic_fetch_or_explicit(const_cast<volatile atomic_int*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_xor(volatile atomic_int* __obj, int __v)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_xor(atomic_int* __obj, int __v)
{
    return atomic_fetch_xor(const_cast<volatile atomic_int*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_xor_explicit(volatile atomic_int* __obj, int __v,
                          memory_order __o)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
int
atomic_fetch_xor_explicit(atomic_int* __obj, int __v, memory_order __o)
{
    return atomic_fetch_xor_explicit(const_cast<volatile atomic_int*>(__obj),
                                                                      __v, __o);
}

// atomic_uint

struct atomic_uint;

bool atomic_is_lock_free(const volatile atomic_uint*);
bool atomic_is_lock_free(const atomic_uint*);
void atomic_init(volatile atomic_uint*, unsigned int);
void atomic_init(atomic_uint*, unsigned int);
void atomic_store(volatile atomic_uint*, unsigned int);
void atomic_store(atomic_uint*, unsigned int);
void atomic_store_explicit(volatile atomic_uint*, unsigned int, memory_order);
void atomic_store_explicit(atomic_uint*, unsigned int, memory_order);
unsigned int atomic_load(const volatile atomic_uint*);
unsigned int atomic_load(const atomic_uint*);
unsigned int atomic_load_explicit(const volatile atomic_uint*, memory_order);
unsigned int atomic_load_explicit(const atomic_uint*, memory_order);
unsigned int atomic_exchange(volatile atomic_uint*, unsigned int);
unsigned int atomic_exchange(atomic_uint*, unsigned int);
unsigned int atomic_exchange_explicit(volatile atomic_uint*, unsigned int,
                                     memory_order);
unsigned int atomic_exchange_explicit(atomic_uint*, unsigned int,
                                       memory_order);
bool atomic_compare_exchange_weak(volatile atomic_uint*, unsigned int*,
                                  unsigned int);
bool atomic_compare_exchange_weak(atomic_uint*, unsigned int*, unsigned int);
bool atomic_compare_exchange_strong(volatile atomic_uint*, unsigned int*,
                                    unsigned int);
bool atomic_compare_exchange_strong(atomic_uint*, unsigned int*,
                                    unsigned int);
bool atomic_compare_exchange_weak_explicit(volatile atomic_uint*,
                                           unsigned int*, unsigned int,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_uint*, unsigned int*,
                                           unsigned int, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_uint*,
                                             unsigned int*, unsigned int,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_uint*, unsigned int*,
                                             unsigned int, memory_order,
                                             memory_order);
unsigned int atomic_fetch_add(volatile atomic_uint*, unsigned int);
unsigned int atomic_fetch_add(atomic_uint*, unsigned int);
unsigned int atomic_fetch_add_explicit(volatile atomic_uint*, unsigned int,
                                        memory_order);
unsigned int atomic_fetch_add_explicit(atomic_uint*, unsigned int,
                                        memory_order);
unsigned int atomic_fetch_sub(volatile atomic_uint*, unsigned int);
unsigned int atomic_fetch_sub(atomic_uint*, unsigned int);
unsigned int atomic_fetch_sub_explicit(volatile atomic_uint*, unsigned int,
                                      memory_order);
unsigned int atomic_fetch_sub_explicit(atomic_uint*, unsigned int,
                                        memory_order);
unsigned int atomic_fetch_and(volatile atomic_uint*, unsigned int);
unsigned int atomic_fetch_and(atomic_uint*, unsigned int);
unsigned int atomic_fetch_and_explicit(volatile atomic_uint*, unsigned int,
                                        memory_order);
unsigned int atomic_fetch_and_explicit(atomic_uint*, unsigned int,
                                        memory_order);
unsigned int atomic_fetch_or(volatile atomic_uint*, unsigned int);
unsigned int atomic_fetch_or(atomic_uint*, unsigned int);
unsigned int atomic_fetch_or_explicit(volatile atomic_uint*, unsigned int,
                                       memory_order);
unsigned int atomic_fetch_or_explicit(atomic_uint*, unsigned int,
                                       memory_order);
unsigned int atomic_fetch_xor(volatile atomic_uint*, unsigned int);
unsigned int atomic_fetch_xor(atomic_uint*, unsigned int);
unsigned int atomic_fetch_xor_explicit(volatile atomic_uint*, unsigned int,
                                        memory_order);
unsigned int atomic_fetch_xor_explicit(atomic_uint*, unsigned int,
                                        memory_order);

typedef struct atomic_uint
{
    unsigned int __v_;

    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const volatile
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    void store(unsigned int __v,
               memory_order __o = memory_order_seq_cst) volatile
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void store(unsigned int __v, memory_order __o = memory_order_seq_cst)
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int load(memory_order __o = memory_order_seq_cst) const volatile
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int load(memory_order __o = memory_order_seq_cst) const
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    operator unsigned int() const volatile
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    operator unsigned int() const
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int exchange(unsigned int __v,
                           memory_order __o = memory_order_seq_cst) volatile
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int exchange(unsigned int __v,
                           memory_order __o = memory_order_seq_cst)
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned int& __v, unsigned int __e,
                               memory_order __s, memory_order __f) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned int& __v, unsigned int __e,
                               memory_order __s, memory_order __f)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned int& __v, unsigned int __e,
                                 memory_order __s, memory_order __f) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned int& __v, unsigned int __e,
                                 memory_order __s, memory_order __f)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned int& __v, unsigned int __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned int& __v, unsigned int __e,
                               memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned int& __v, unsigned int __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned int& __v, unsigned int __e,
                                 memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int fetch_add(unsigned int __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int fetch_add(unsigned int __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int fetch_sub(unsigned int __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int fetch_sub(unsigned int __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int fetch_and(unsigned int __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int fetch_and(unsigned int __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int fetch_or(unsigned int __v,
                           memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int fetch_or(unsigned int __v,
                           memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int fetch_xor(unsigned int __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_xor_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int fetch_xor(unsigned int __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_xor_explicit(this, __v, __o);}
#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_uint() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_uint() {}
#endif
    _LIBCPP_INLINE_VISIBILITY
    /*constexpr*/ atomic_uint(unsigned int __v)
        : __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_uint(const atomic_uint&) = delete;
    atomic_uint& operator=(const atomic_uint&) = delete;
    atomic_uint& operator=(const atomic_uint&) volatile = delete;
#else
private:
    atomic_uint(const atomic_uint&);
    atomic_uint& operator=(const atomic_uint&);
    atomic_uint& operator=(const atomic_uint&) volatile;
public:
#endif
    _LIBCPP_INLINE_VISIBILITY
    unsigned int operator=(unsigned int __v) volatile
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int operator=(unsigned int __v)
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    unsigned int operator++(int) volatile
        {typedef unsigned int type; return fetch_add(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    int operator++(int)
        {typedef unsigned int type; return fetch_add(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    int operator--(int) volatile
        {typedef unsigned int type; return fetch_sub(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    int operator--(int)
        {typedef unsigned int type; return fetch_sub(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    int operator++() volatile
        {typedef unsigned int type; return type(fetch_add(type(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    int operator++()
        {typedef unsigned int type; return type(fetch_add(type(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    int operator--() volatile
        {typedef unsigned int type; return type(fetch_sub(type(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    int operator--()
        {typedef unsigned int type; return type(fetch_sub(type(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    int operator+=(int __v) volatile
        {typedef unsigned int type; return type(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator+=(int __v)
        {typedef unsigned int type; return type(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator-=(int __v) volatile
        {typedef unsigned int type; return type(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator-=(int __v)
        {typedef unsigned int type; return type(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator&=(int __v) volatile
        {typedef unsigned int type; return type(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator&=(int __v)
        {typedef unsigned int type; return type(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator|=(int __v) volatile
        {typedef unsigned int type; return type(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator|=(int __v)
        {typedef unsigned int type; return type(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator^=(int __v) volatile
        {typedef unsigned int type; return type(fetch_xor(__v) ^ __v);}
    _LIBCPP_INLINE_VISIBILITY
    int operator^=(int __v)
        {typedef unsigned int type; return type(fetch_xor(__v) ^ __v);}
} atomic_uint;

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const volatile atomic_uint*)
{
    typedef unsigned int type;
    return __atomic_is_lock_free(type);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const atomic_uint* __obj)
{
    return atomic_is_lock_free(const_cast<volatile atomic_uint*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(volatile atomic_uint* __obj, unsigned int __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(atomic_uint* __obj, unsigned int __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(volatile atomic_uint* __obj, unsigned int __desr)
{
    __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(atomic_uint* __obj, unsigned int __desr)
{
    atomic_store(const_cast<volatile atomic_uint*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(volatile atomic_uint* __obj, unsigned int __desr,
                      memory_order __o)
{
    __atomic_store(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(atomic_uint* __obj, unsigned int __desr,
                      memory_order __o)
{
    atomic_store_explicit(const_cast<volatile atomic_uint*>(__obj), __desr,
                                                                           __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_load(const volatile atomic_uint* __obj)
{
    return __atomic_load(&__obj->__v_, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_load(const atomic_uint* __obj)
{
    return atomic_load(const_cast<const volatile atomic_uint*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_load_explicit(const volatile atomic_uint* __obj, memory_order __o)
{
    return __atomic_load(&__obj->__v_, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_load_explicit(const atomic_uint* __obj, memory_order __o)
{
    return atomic_load_explicit(const_cast<const volatile atomic_uint*>
                                                                  (__obj), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_exchange(volatile atomic_uint* __obj, unsigned int __desr)
{
    return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_exchange(atomic_uint* __obj, unsigned int __desr)
{
    return atomic_exchange(const_cast<volatile atomic_uint*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_exchange_explicit(volatile atomic_uint* __obj, unsigned int __desr,
                         memory_order __o)
{
    return __atomic_exchange(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_exchange_explicit(atomic_uint* __obj, unsigned int __desr,
                         memory_order __o)
{
    return atomic_exchange_explicit(const_cast<volatile atomic_uint*>
                                                          (__obj), __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(volatile atomic_uint* __obj, unsigned int* __exp,
                             unsigned int __desr)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(atomic_uint* __obj, unsigned int* __exp,
                             unsigned int __desr)
{
    return atomic_compare_exchange_weak(const_cast<volatile atomic_uint*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(volatile atomic_uint* __obj,
                               unsigned int* __exp, unsigned int __desr)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(atomic_uint* __obj, unsigned int* __exp,
                               unsigned int __desr)
{
    return atomic_compare_exchange_strong(const_cast<volatile atomic_uint*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(volatile atomic_uint* __obj,
                                      unsigned int* __exp,
                                      unsigned int __desr, memory_order __s,
                                      memory_order __f)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(atomic_uint* __obj, unsigned int* __exp,
                                      unsigned int __desr, memory_order __s,
                                      memory_order __f)
{
    return atomic_compare_exchange_weak_explicit(
             const_cast<volatile atomic_uint*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(volatile atomic_uint* __obj,
                                        unsigned int* __exp,
                                        unsigned int __desr, memory_order __s,
                                        memory_order __f)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(atomic_uint* __obj,
                                        unsigned int* __exp,
                                        unsigned int __desr, memory_order __s,
                                        memory_order __f)
{
    return atomic_compare_exchange_strong_explicit(
             const_cast<volatile atomic_uint*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_add(volatile atomic_uint* __obj, unsigned int __v)
{
    return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_add(atomic_uint* __obj, unsigned int __v)
{
    return atomic_fetch_add(const_cast<volatile atomic_uint*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_add_explicit(volatile atomic_uint* __obj, unsigned int __v,
                          memory_order __o)
{
    return __atomic_fetch_add(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_add_explicit(atomic_uint* __obj, unsigned int __v,
                          memory_order __o)
{
    return atomic_fetch_add_explicit(const_cast<volatile atomic_uint*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_sub(volatile atomic_uint* __obj, unsigned int __v)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_sub(atomic_uint* __obj, unsigned int __v)
{
    return atomic_fetch_sub(const_cast<volatile atomic_uint*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_sub_explicit(volatile atomic_uint* __obj, unsigned int __v,
                          memory_order __o)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_sub_explicit(atomic_uint* __obj, unsigned int __v,
                          memory_order __o)
{
    return atomic_fetch_sub_explicit(const_cast<volatile atomic_uint*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_and(volatile atomic_uint* __obj, unsigned int __v)
{
    return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_and(atomic_uint* __obj, unsigned int __v)
{
    return atomic_fetch_and(const_cast<volatile atomic_uint*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_and_explicit(volatile atomic_uint* __obj, unsigned int __v,
                          memory_order __o)
{
    return __atomic_fetch_and(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_and_explicit(atomic_uint* __obj, unsigned int __v,
                          memory_order __o)
{
    return atomic_fetch_and_explicit(const_cast<volatile atomic_uint*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_or(volatile atomic_uint* __obj, unsigned int __v)
{
    return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_or(atomic_uint* __obj, unsigned int __v)
{
    return atomic_fetch_or(const_cast<volatile atomic_uint*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_or_explicit(volatile atomic_uint* __obj, unsigned int __v,
                         memory_order __o)
{
    return __atomic_fetch_or(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_or_explicit(atomic_uint* __obj, unsigned int __v,
                         memory_order __o)
{
    return atomic_fetch_or_explicit(const_cast<volatile atomic_uint*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_xor(volatile atomic_uint* __obj, unsigned int __v)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_xor(atomic_uint* __obj, unsigned int __v)
{
    return atomic_fetch_xor(const_cast<volatile atomic_uint*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_xor_explicit(volatile atomic_uint* __obj, unsigned int __v,
                          memory_order __o)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned int
atomic_fetch_xor_explicit(atomic_uint* __obj, unsigned int __v,
                          memory_order __o)
{
    return atomic_fetch_xor_explicit(const_cast<volatile atomic_uint*>(__obj),
                                                                      __v, __o);
}

// atomic_long

struct atomic_long;

bool atomic_is_lock_free(const volatile atomic_long*);
bool atomic_is_lock_free(const atomic_long*);
void atomic_init(volatile atomic_long*, long);
void atomic_init(atomic_long*, long);
void atomic_store(volatile atomic_long*, long);
void atomic_store(atomic_long*, long);
void atomic_store_explicit(volatile atomic_long*, long, memory_order);
void atomic_store_explicit(atomic_long*, long, memory_order);
long atomic_load(const volatile atomic_long*);
long atomic_load(const atomic_long*);
long atomic_load_explicit(const volatile atomic_long*, memory_order);
long atomic_load_explicit(const atomic_long*, memory_order);
long atomic_exchange(volatile atomic_long*, long);
long atomic_exchange(atomic_long*, long);
long atomic_exchange_explicit(volatile atomic_long*, long, memory_order);
long atomic_exchange_explicit(atomic_long*, long, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_long*, long*, long);
bool atomic_compare_exchange_weak(atomic_long*, long*, long);
bool atomic_compare_exchange_strong(volatile atomic_long*, long*, long);
bool atomic_compare_exchange_strong(atomic_long*, long*, long);
bool atomic_compare_exchange_weak_explicit(volatile atomic_long*, long*, long,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_long*, long*, long,
                                           memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_long*, long*, long,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_long*, long*, long,
                                             memory_order, memory_order);
long atomic_fetch_add(volatile atomic_long*, long);
long atomic_fetch_add(atomic_long*, long);
long atomic_fetch_add_explicit(volatile atomic_long*, long, memory_order);
long atomic_fetch_add_explicit(atomic_long*, long, memory_order);
long atomic_fetch_sub(volatile atomic_long*, long);
long atomic_fetch_sub(atomic_long*, long);
long atomic_fetch_sub_explicit(volatile atomic_long*, long, memory_order);
long atomic_fetch_sub_explicit(atomic_long*, long, memory_order);
long atomic_fetch_and(volatile atomic_long*, long);
long atomic_fetch_and(atomic_long*, long);
long atomic_fetch_and_explicit(volatile atomic_long*, long, memory_order);
long atomic_fetch_and_explicit(atomic_long*, long, memory_order);
long atomic_fetch_or(volatile atomic_long*, long);
long atomic_fetch_or(atomic_long*, long);
long atomic_fetch_or_explicit(volatile atomic_long*, long, memory_order);
long atomic_fetch_or_explicit(atomic_long*, long, memory_order);
long atomic_fetch_xor(volatile atomic_long*, long);
long atomic_fetch_xor(atomic_long*, long);
long atomic_fetch_xor_explicit(volatile atomic_long*, long, memory_order);
long atomic_fetch_xor_explicit(atomic_long*, long, memory_order);

typedef struct atomic_long
{
    long __v_;

    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const volatile
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    void store(long __v, memory_order __o = memory_order_seq_cst) volatile
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void store(long __v, memory_order __o = memory_order_seq_cst)
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long load(memory_order __o = memory_order_seq_cst) const volatile
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long load(memory_order __o = memory_order_seq_cst) const
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    operator long() const volatile
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    operator long() const
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    long exchange(long __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long exchange(long __v, memory_order __o = memory_order_seq_cst)
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(long& __v, long __e, memory_order __s,
                               memory_order __f) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(long& __v, long __e, memory_order __s,
                               memory_order __f)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(long& __v, long __e, memory_order __s,
                                 memory_order __f) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(long& __v, long __e, memory_order __s,
                                 memory_order __f)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(long& __v, long __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(long& __v, long __e,
                               memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(long& __v, long __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(long& __v, long __e,
                                 memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    long fetch_add(long __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long fetch_add(long __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long fetch_sub(long __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long fetch_sub(long __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long fetch_and(long __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long fetch_and(long __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long fetch_or(long __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long fetch_or(long __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long fetch_xor(long __v, memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_xor_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long fetch_xor(long __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_xor_explicit(this, __v, __o);}
#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_long() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_long() {}
#endif
    _LIBCPP_INLINE_VISIBILITY
    /*constexpr*/ atomic_long(long __v)
        : __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_long(const atomic_long&) = delete;
    atomic_long& operator=(const atomic_long&) = delete;
    atomic_long& operator=(const atomic_long&) volatile = delete;
#else
private:
    atomic_long(const atomic_long&);
    atomic_long& operator=(const atomic_long&);
    atomic_long& operator=(const atomic_long&) volatile;
public:
#endif
    _LIBCPP_INLINE_VISIBILITY
    long operator=(long __v) volatile
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    long operator=(long __v)
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    long operator++(int) volatile
        {return fetch_add(long(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator++(int)
        {return fetch_add(long(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator--(int) volatile
        {return fetch_sub(long(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator--(int)
        {return fetch_sub(long(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator++() volatile
        {return long(fetch_add(long(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator++()
        {return long(fetch_add(long(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator--() volatile
        {return long(fetch_sub(long(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator--()
        {return long(fetch_sub(long(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator+=(long __v) volatile
        {return long(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator+=(long __v)
        {return long(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator-=(long __v) volatile
        {return long(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator-=(long __v)
        {return long(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator&=(long __v) volatile
        {return long(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator&=(long __v)
        {return long(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator|=(long __v) volatile
        {return long(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator|=(long __v)
        {return long(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator^=(long __v) volatile
        {return long(fetch_xor(__v) ^ __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator^=(long __v)
        {return long(fetch_xor(__v) ^ __v);}
} atomic_long;

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const volatile atomic_long*)
{
    typedef long type;
    return __atomic_is_lock_free(type);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const atomic_long* __obj)
{
    return atomic_is_lock_free(const_cast<volatile atomic_long*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(volatile atomic_long* __obj, long __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(atomic_long* __obj, long __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(volatile atomic_long* __obj, long __desr)
{
    __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(atomic_long* __obj, long __desr)
{
    atomic_store(const_cast<volatile atomic_long*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(volatile atomic_long* __obj, long __desr,
                      memory_order __o)
{
    __atomic_store(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(atomic_long* __obj, long __desr, memory_order __o)
{
    atomic_store_explicit(const_cast<volatile atomic_long*>(__obj), __desr,
                                                                           __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_load(const volatile atomic_long* __obj)
{
    return __atomic_load(&__obj->__v_, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_load(const atomic_long* __obj)
{
    return atomic_load(const_cast<const volatile atomic_long*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_load_explicit(const volatile atomic_long* __obj, memory_order __o)
{
    return __atomic_load(&__obj->__v_, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_load_explicit(const atomic_long* __obj, memory_order __o)
{
    return atomic_load_explicit(const_cast<const volatile atomic_long*>
                                                                  (__obj), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_exchange(volatile atomic_long* __obj, long __desr)
{
    return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_exchange(atomic_long* __obj, long __desr)
{
    return atomic_exchange(const_cast<volatile atomic_long*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_exchange_explicit(volatile atomic_long* __obj, long __desr,
                         memory_order __o)
{
    return __atomic_exchange(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_exchange_explicit(atomic_long* __obj, long __desr, memory_order __o)
{
    return atomic_exchange_explicit(const_cast<volatile atomic_long*>
                                                          (__obj), __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(volatile atomic_long* __obj, long* __exp,
                             long __desr)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(atomic_long* __obj, long* __exp, long __desr)
{
    return atomic_compare_exchange_weak(const_cast<volatile atomic_long*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(volatile atomic_long* __obj, long* __exp,
                               long __desr)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(atomic_long* __obj, long* __exp, long __desr)
{
    return atomic_compare_exchange_strong(const_cast<volatile atomic_long*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(volatile atomic_long* __obj, long* __exp,
                                      long __desr, memory_order __s,
                                      memory_order __f)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(atomic_long* __obj, long* __exp,
                                      long __desr, memory_order __s,
                                      memory_order __f)
{
    return atomic_compare_exchange_weak_explicit(
             const_cast<volatile atomic_long*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(volatile atomic_long* __obj,
                                        long* __exp, long __desr,
                                        memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(atomic_long* __obj, long* __exp,
                                        long __desr, memory_order __s,
                                        memory_order __f)
{
    return atomic_compare_exchange_strong_explicit(
             const_cast<volatile atomic_long*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_add(volatile atomic_long* __obj, long __v)
{
    return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_add(atomic_long* __obj, long __v)
{
    return atomic_fetch_add(const_cast<volatile atomic_long*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_add_explicit(volatile atomic_long* __obj, long __v,
                          memory_order __o)
{
    return __atomic_fetch_add(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_add_explicit(atomic_long* __obj, long __v, memory_order __o)
{
    return atomic_fetch_add_explicit(const_cast<volatile atomic_long*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_sub(volatile atomic_long* __obj, long __v)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_sub(atomic_long* __obj, long __v)
{
    return atomic_fetch_sub(const_cast<volatile atomic_long*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_sub_explicit(volatile atomic_long* __obj, long __v,
                          memory_order __o)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_sub_explicit(atomic_long* __obj, long __v, memory_order __o)
{
    return atomic_fetch_sub_explicit(const_cast<volatile atomic_long*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_and(volatile atomic_long* __obj, long __v)
{
    return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_and(atomic_long* __obj, long __v)
{
    return atomic_fetch_and(const_cast<volatile atomic_long*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_and_explicit(volatile atomic_long* __obj, long __v,
                          memory_order __o)
{
    return __atomic_fetch_and(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_and_explicit(atomic_long* __obj, long __v, memory_order __o)
{
    return atomic_fetch_and_explicit(const_cast<volatile atomic_long*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_or(volatile atomic_long* __obj, long __v)
{
    return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_or(atomic_long* __obj, long __v)
{
    return atomic_fetch_or(const_cast<volatile atomic_long*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_or_explicit(volatile atomic_long* __obj, long __v,
                         memory_order __o)
{
    return __atomic_fetch_or(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_or_explicit(atomic_long* __obj, long __v, memory_order __o)
{
    return atomic_fetch_or_explicit(const_cast<volatile atomic_long*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_xor(volatile atomic_long* __obj, long __v)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_xor(atomic_long* __obj, long __v)
{
    return atomic_fetch_xor(const_cast<volatile atomic_long*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_xor_explicit(volatile atomic_long* __obj, long __v,
                          memory_order __o)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long
atomic_fetch_xor_explicit(atomic_long* __obj, long __v, memory_order __o)
{
    return atomic_fetch_xor_explicit(const_cast<volatile atomic_long*>(__obj),
                                                                      __v, __o);
}

// atomic_ulong

struct atomic_ulong;

bool atomic_is_lock_free(const volatile atomic_ulong*);
bool atomic_is_lock_free(const atomic_ulong*);
void atomic_init(volatile atomic_ulong*, unsigned long);
void atomic_init(atomic_ulong*, unsigned long);
void atomic_store(volatile atomic_ulong*, unsigned long);
void atomic_store(atomic_ulong*, unsigned long);
void atomic_store_explicit(volatile atomic_ulong*, unsigned long, memory_order);
void atomic_store_explicit(atomic_ulong*, unsigned long, memory_order);
unsigned long atomic_load(const volatile atomic_ulong*);
unsigned long atomic_load(const atomic_ulong*);
unsigned long atomic_load_explicit(const volatile atomic_ulong*, memory_order);
unsigned long atomic_load_explicit(const atomic_ulong*, memory_order);
unsigned long atomic_exchange(volatile atomic_ulong*, unsigned long);
unsigned long atomic_exchange(atomic_ulong*, unsigned long);
unsigned long atomic_exchange_explicit(volatile atomic_ulong*, unsigned long,
                                     memory_order);
unsigned long atomic_exchange_explicit(atomic_ulong*, unsigned long,
                                       memory_order);
bool atomic_compare_exchange_weak(volatile atomic_ulong*, unsigned long*,
                                  unsigned long);
bool atomic_compare_exchange_weak(atomic_ulong*, unsigned long*, unsigned long);
bool atomic_compare_exchange_strong(volatile atomic_ulong*, unsigned long*,
                                    unsigned long);
bool atomic_compare_exchange_strong(atomic_ulong*, unsigned long*,
                                    unsigned long);
bool atomic_compare_exchange_weak_explicit(volatile atomic_ulong*,
                                           unsigned long*, unsigned long,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_ulong*, unsigned long*,
                                           unsigned long, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_ulong*,
                                             unsigned long*, unsigned long,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_ulong*, unsigned long*,
                                             unsigned long, memory_order,
                                             memory_order);
unsigned long atomic_fetch_add(volatile atomic_ulong*, unsigned long);
unsigned long atomic_fetch_add(atomic_ulong*, unsigned long);
unsigned long atomic_fetch_add_explicit(volatile atomic_ulong*, unsigned long,
                                        memory_order);
unsigned long atomic_fetch_add_explicit(atomic_ulong*, unsigned long,
                                        memory_order);
unsigned long atomic_fetch_sub(volatile atomic_ulong*, unsigned long);
unsigned long atomic_fetch_sub(atomic_ulong*, unsigned long);
unsigned long atomic_fetch_sub_explicit(volatile atomic_ulong*, unsigned long,
                                      memory_order);
unsigned long atomic_fetch_sub_explicit(atomic_ulong*, unsigned long,
                                        memory_order);
unsigned long atomic_fetch_and(volatile atomic_ulong*, unsigned long);
unsigned long atomic_fetch_and(atomic_ulong*, unsigned long);
unsigned long atomic_fetch_and_explicit(volatile atomic_ulong*, unsigned long,
                                        memory_order);
unsigned long atomic_fetch_and_explicit(atomic_ulong*, unsigned long,
                                        memory_order);
unsigned long atomic_fetch_or(volatile atomic_ulong*, unsigned long);
unsigned long atomic_fetch_or(atomic_ulong*, unsigned long);
unsigned long atomic_fetch_or_explicit(volatile atomic_ulong*, unsigned long,
                                       memory_order);
unsigned long atomic_fetch_or_explicit(atomic_ulong*, unsigned long,
                                       memory_order);
unsigned long atomic_fetch_xor(volatile atomic_ulong*, unsigned long);
unsigned long atomic_fetch_xor(atomic_ulong*, unsigned long);
unsigned long atomic_fetch_xor_explicit(volatile atomic_ulong*, unsigned long,
                                        memory_order);
unsigned long atomic_fetch_xor_explicit(atomic_ulong*, unsigned long,
                                        memory_order);

typedef struct atomic_ulong
{
    unsigned long __v_;

    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const volatile
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    void store(unsigned long __v,
               memory_order __o = memory_order_seq_cst) volatile
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void store(unsigned long __v, memory_order __o = memory_order_seq_cst)
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long load(memory_order __o = memory_order_seq_cst) const volatile
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long load(memory_order __o = memory_order_seq_cst) const
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    operator unsigned long() const volatile
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    operator unsigned long() const
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long exchange(unsigned long __v,
                           memory_order __o = memory_order_seq_cst) volatile
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long exchange(unsigned long __v,
                           memory_order __o = memory_order_seq_cst)
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned long& __v, unsigned long __e,
                               memory_order __s, memory_order __f) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned long& __v, unsigned long __e,
                               memory_order __s, memory_order __f)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned long& __v, unsigned long __e,
                                 memory_order __s, memory_order __f) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned long& __v, unsigned long __e,
                                 memory_order __s, memory_order __f)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned long& __v, unsigned long __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned long& __v, unsigned long __e,
                               memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned long& __v, unsigned long __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned long& __v, unsigned long __e,
                                 memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long fetch_add(unsigned long __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long fetch_add(unsigned long __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long fetch_sub(unsigned long __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long fetch_sub(unsigned long __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long fetch_and(unsigned long __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long fetch_and(unsigned long __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long fetch_or(unsigned long __v,
                           memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long fetch_or(unsigned long __v,
                           memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long fetch_xor(unsigned long __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_xor_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long fetch_xor(unsigned long __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_xor_explicit(this, __v, __o);}
#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_ulong() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_ulong() {}
#endif
    _LIBCPP_INLINE_VISIBILITY
    /*constexpr*/ atomic_ulong(unsigned long __v)
        : __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_ulong(const atomic_ulong&) = delete;
    atomic_ulong& operator=(const atomic_ulong&) = delete;
    atomic_ulong& operator=(const atomic_ulong&) volatile = delete;
#else
private:
    atomic_ulong(const atomic_ulong&);
    atomic_ulong& operator=(const atomic_ulong&);
    atomic_ulong& operator=(const atomic_ulong&) volatile;
public:
#endif
    _LIBCPP_INLINE_VISIBILITY
    unsigned long operator=(unsigned long __v) volatile
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long operator=(unsigned long __v)
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long operator++(int) volatile
        {typedef unsigned long type; return fetch_add(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator++(int)
        {typedef unsigned long type; return fetch_add(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator--(int) volatile
        {typedef unsigned long type; return fetch_sub(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator--(int)
        {typedef unsigned long type; return fetch_sub(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator++() volatile
        {typedef unsigned long type; return type(fetch_add(type(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator++()
        {typedef unsigned long type; return type(fetch_add(type(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator--() volatile
        {typedef unsigned long type; return type(fetch_sub(type(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator--()
        {typedef unsigned long type; return type(fetch_sub(type(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator+=(long __v) volatile
        {typedef unsigned long type; return type(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator+=(long __v)
        {typedef unsigned long type; return type(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator-=(long __v) volatile
        {typedef unsigned long type; return type(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator-=(long __v)
        {typedef unsigned long type; return type(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator&=(long __v) volatile
        {typedef unsigned long type; return type(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator&=(long __v)
        {typedef unsigned long type; return type(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator|=(long __v) volatile
        {typedef unsigned long type; return type(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator|=(long __v)
        {typedef unsigned long type; return type(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator^=(long __v) volatile
        {typedef unsigned long type; return type(fetch_xor(__v) ^ __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator^=(long __v)
        {typedef unsigned long type; return type(fetch_xor(__v) ^ __v);}
} atomic_ulong;

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const volatile atomic_ulong*)
{
    typedef unsigned long type;
    return __atomic_is_lock_free(type);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const atomic_ulong* __obj)
{
    return atomic_is_lock_free(const_cast<volatile atomic_ulong*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(volatile atomic_ulong* __obj, unsigned long __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(atomic_ulong* __obj, unsigned long __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(volatile atomic_ulong* __obj, unsigned long __desr)
{
    __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(atomic_ulong* __obj, unsigned long __desr)
{
    atomic_store(const_cast<volatile atomic_ulong*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(volatile atomic_ulong* __obj, unsigned long __desr,
                      memory_order __o)
{
    __atomic_store(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(atomic_ulong* __obj, unsigned long __desr,
                      memory_order __o)
{
    atomic_store_explicit(const_cast<volatile atomic_ulong*>(__obj), __desr,
                                                                           __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_load(const volatile atomic_ulong* __obj)
{
    return __atomic_load(&__obj->__v_, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_load(const atomic_ulong* __obj)
{
    return atomic_load(const_cast<const volatile atomic_ulong*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_load_explicit(const volatile atomic_ulong* __obj, memory_order __o)
{
    return __atomic_load(&__obj->__v_, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_load_explicit(const atomic_ulong* __obj, memory_order __o)
{
    return atomic_load_explicit(const_cast<const volatile atomic_ulong*>
                                                                  (__obj), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_exchange(volatile atomic_ulong* __obj, unsigned long __desr)
{
    return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_exchange(atomic_ulong* __obj, unsigned long __desr)
{
    return atomic_exchange(const_cast<volatile atomic_ulong*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_exchange_explicit(volatile atomic_ulong* __obj, unsigned long __desr,
                         memory_order __o)
{
    return __atomic_exchange(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_exchange_explicit(atomic_ulong* __obj, unsigned long __desr,
                         memory_order __o)
{
    return atomic_exchange_explicit(const_cast<volatile atomic_ulong*>
                                                          (__obj), __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(volatile atomic_ulong* __obj, unsigned long* __exp,
                             unsigned long __desr)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(atomic_ulong* __obj, unsigned long* __exp,
                             unsigned long __desr)
{
    return atomic_compare_exchange_weak(const_cast<volatile atomic_ulong*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(volatile atomic_ulong* __obj,
                               unsigned long* __exp, unsigned long __desr)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(atomic_ulong* __obj, unsigned long* __exp,
                               unsigned long __desr)
{
    return atomic_compare_exchange_strong(const_cast<volatile atomic_ulong*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(volatile atomic_ulong* __obj,
                                      unsigned long* __exp,
                                      unsigned long __desr, memory_order __s,
                                      memory_order __f)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(atomic_ulong* __obj, unsigned long* __exp,
                                      unsigned long __desr, memory_order __s,
                                      memory_order __f)
{
    return atomic_compare_exchange_weak_explicit(
             const_cast<volatile atomic_ulong*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(volatile atomic_ulong* __obj,
                                        unsigned long* __exp,
                                        unsigned long __desr, memory_order __s,
                                        memory_order __f)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(atomic_ulong* __obj,
                                        unsigned long* __exp,
                                        unsigned long __desr, memory_order __s,
                                        memory_order __f)
{
    return atomic_compare_exchange_strong_explicit(
             const_cast<volatile atomic_ulong*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_add(volatile atomic_ulong* __obj, unsigned long __v)
{
    return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_add(atomic_ulong* __obj, unsigned long __v)
{
    return atomic_fetch_add(const_cast<volatile atomic_ulong*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_add_explicit(volatile atomic_ulong* __obj, unsigned long __v,
                          memory_order __o)
{
    return __atomic_fetch_add(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_add_explicit(atomic_ulong* __obj, unsigned long __v,
                          memory_order __o)
{
    return atomic_fetch_add_explicit(const_cast<volatile atomic_ulong*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_sub(volatile atomic_ulong* __obj, unsigned long __v)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_sub(atomic_ulong* __obj, unsigned long __v)
{
    return atomic_fetch_sub(const_cast<volatile atomic_ulong*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_sub_explicit(volatile atomic_ulong* __obj, unsigned long __v,
                          memory_order __o)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_sub_explicit(atomic_ulong* __obj, unsigned long __v,
                          memory_order __o)
{
    return atomic_fetch_sub_explicit(const_cast<volatile atomic_ulong*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_and(volatile atomic_ulong* __obj, unsigned long __v)
{
    return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_and(atomic_ulong* __obj, unsigned long __v)
{
    return atomic_fetch_and(const_cast<volatile atomic_ulong*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_and_explicit(volatile atomic_ulong* __obj, unsigned long __v,
                          memory_order __o)
{
    return __atomic_fetch_and(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_and_explicit(atomic_ulong* __obj, unsigned long __v,
                          memory_order __o)
{
    return atomic_fetch_and_explicit(const_cast<volatile atomic_ulong*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_or(volatile atomic_ulong* __obj, unsigned long __v)
{
    return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_or(atomic_ulong* __obj, unsigned long __v)
{
    return atomic_fetch_or(const_cast<volatile atomic_ulong*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_or_explicit(volatile atomic_ulong* __obj, unsigned long __v,
                         memory_order __o)
{
    return __atomic_fetch_or(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_or_explicit(atomic_ulong* __obj, unsigned long __v,
                         memory_order __o)
{
    return atomic_fetch_or_explicit(const_cast<volatile atomic_ulong*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_xor(volatile atomic_ulong* __obj, unsigned long __v)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_xor(atomic_ulong* __obj, unsigned long __v)
{
    return atomic_fetch_xor(const_cast<volatile atomic_ulong*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_xor_explicit(volatile atomic_ulong* __obj, unsigned long __v,
                          memory_order __o)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long
atomic_fetch_xor_explicit(atomic_ulong* __obj, unsigned long __v,
                          memory_order __o)
{
    return atomic_fetch_xor_explicit(const_cast<volatile atomic_ulong*>(__obj),
                                                                      __v, __o);
}

// atomic_llong

struct atomic_llong;

bool atomic_is_lock_free(const volatile atomic_llong*);
bool atomic_is_lock_free(const atomic_llong*);
void atomic_init(volatile atomic_llong*, long long);
void atomic_init(atomic_llong*, long long);
void atomic_store(volatile atomic_llong*, long long);
void atomic_store(atomic_llong*, long long);
void atomic_store_explicit(volatile atomic_llong*, long long, memory_order);
void atomic_store_explicit(atomic_llong*, long long, memory_order);
long long atomic_load(const volatile atomic_llong*);
long long atomic_load(const atomic_llong*);
long long atomic_load_explicit(const volatile atomic_llong*, memory_order);
long long atomic_load_explicit(const atomic_llong*, memory_order);
long long atomic_exchange(volatile atomic_llong*, long long);
long long atomic_exchange(atomic_llong*, long long);
long long atomic_exchange_explicit(volatile atomic_llong*, long long,
                                     memory_order);
long long atomic_exchange_explicit(atomic_llong*, long long,
                                       memory_order);
bool atomic_compare_exchange_weak(volatile atomic_llong*, long long*,
                                  long long);
bool atomic_compare_exchange_weak(atomic_llong*, long long*, long long);
bool atomic_compare_exchange_strong(volatile atomic_llong*, long long*,
                                    long long);
bool atomic_compare_exchange_strong(atomic_llong*, long long*,
                                    long long);
bool atomic_compare_exchange_weak_explicit(volatile atomic_llong*,
                                           long long*, long long,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_llong*, long long*,
                                           long long, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_llong*,
                                             long long*, long long,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_llong*, long long*,
                                             long long, memory_order,
                                             memory_order);
long long atomic_fetch_add(volatile atomic_llong*, long long);
long long atomic_fetch_add(atomic_llong*, long long);
long long atomic_fetch_add_explicit(volatile atomic_llong*, long long,
                                        memory_order);
long long atomic_fetch_add_explicit(atomic_llong*, long long,
                                        memory_order);
long long atomic_fetch_sub(volatile atomic_llong*, long long);
long long atomic_fetch_sub(atomic_llong*, long long);
long long atomic_fetch_sub_explicit(volatile atomic_llong*, long long,
                                      memory_order);
long long atomic_fetch_sub_explicit(atomic_llong*, long long,
                                        memory_order);
long long atomic_fetch_and(volatile atomic_llong*, long long);
long long atomic_fetch_and(atomic_llong*, long long);
long long atomic_fetch_and_explicit(volatile atomic_llong*, long long,
                                        memory_order);
long long atomic_fetch_and_explicit(atomic_llong*, long long,
                                        memory_order);
long long atomic_fetch_or(volatile atomic_llong*, long long);
long long atomic_fetch_or(atomic_llong*, long long);
long long atomic_fetch_or_explicit(volatile atomic_llong*, long long,
                                       memory_order);
long long atomic_fetch_or_explicit(atomic_llong*, long long,
                                       memory_order);
long long atomic_fetch_xor(volatile atomic_llong*, long long);
long long atomic_fetch_xor(atomic_llong*, long long);
long long atomic_fetch_xor_explicit(volatile atomic_llong*, long long,
                                        memory_order);
long long atomic_fetch_xor_explicit(atomic_llong*, long long,
                                        memory_order);

typedef struct atomic_llong
{
    long long __v_;

    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const volatile
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    void store(long long __v,
               memory_order __o = memory_order_seq_cst) volatile
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void store(long long __v, memory_order __o = memory_order_seq_cst)
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long long load(memory_order __o = memory_order_seq_cst) const volatile
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long long load(memory_order __o = memory_order_seq_cst) const
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    operator long long() const volatile
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    operator long long() const
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    long long exchange(long long __v,
                           memory_order __o = memory_order_seq_cst) volatile
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long long exchange(long long __v,
                           memory_order __o = memory_order_seq_cst)
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(long long& __v, long long __e,
                               memory_order __s, memory_order __f) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(long long& __v, long long __e,
                               memory_order __s, memory_order __f)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(long long& __v, long long __e,
                                 memory_order __s, memory_order __f) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(long long& __v, long long __e,
                                 memory_order __s, memory_order __f)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(long long& __v, long long __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(long long& __v, long long __e,
                               memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(long long& __v, long long __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(long long& __v, long long __e,
                                 memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    long long fetch_add(long long __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long long fetch_add(long long __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long long fetch_sub(long long __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long long fetch_sub(long long __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long long fetch_and(long long __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long long fetch_and(long long __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long long fetch_or(long long __v,
                           memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long long fetch_or(long long __v,
                           memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long long fetch_xor(long long __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_xor_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    long long fetch_xor(long long __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_xor_explicit(this, __v, __o);}
#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_llong() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_llong() {}
#endif
    _LIBCPP_INLINE_VISIBILITY
    /*constexpr*/ atomic_llong(long long __v)
        : __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_llong(const atomic_llong&) = delete;
    atomic_llong& operator=(const atomic_llong&) = delete;
    atomic_llong& operator=(const atomic_llong&) volatile = delete;
#else
private:
    atomic_llong(const atomic_llong&);
    atomic_llong& operator=(const atomic_llong&);
    atomic_llong& operator=(const atomic_llong&) volatile;
public:
#endif
    _LIBCPP_INLINE_VISIBILITY
    long long operator=(long long __v) volatile
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    long long operator=(long long __v)
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    long long operator++(int) volatile
        {typedef long long type; return fetch_add(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator++(int)
        {typedef long long type; return fetch_add(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator--(int) volatile
        {typedef long long type; return fetch_sub(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator--(int)
        {typedef long long type; return fetch_sub(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator++() volatile
        {typedef long long type; return type(fetch_add(type(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator++()
        {typedef long long type; return type(fetch_add(type(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator--() volatile
        {typedef long long type; return type(fetch_sub(type(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator--()
        {typedef long long type; return type(fetch_sub(type(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator+=(long __v) volatile
        {typedef long long type; return type(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator+=(long __v)
        {typedef long long type; return type(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator-=(long __v) volatile
        {typedef long long type; return type(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator-=(long __v)
        {typedef long long type; return type(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator&=(long __v) volatile
        {typedef long long type; return type(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator&=(long __v)
        {typedef long long type; return type(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator|=(long __v) volatile
        {typedef long long type; return type(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator|=(long __v)
        {typedef long long type; return type(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator^=(long __v) volatile
        {typedef long long type; return type(fetch_xor(__v) ^ __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator^=(long __v)
        {typedef long long type; return type(fetch_xor(__v) ^ __v);}
} atomic_llong;

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const volatile atomic_llong*)
{
    typedef long long type;
    return __atomic_is_lock_free(type);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const atomic_llong* __obj)
{
    return atomic_is_lock_free(const_cast<volatile atomic_llong*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(volatile atomic_llong* __obj, long long __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(atomic_llong* __obj, long long __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(volatile atomic_llong* __obj, long long __desr)
{
    __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(atomic_llong* __obj, long long __desr)
{
    atomic_store(const_cast<volatile atomic_llong*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(volatile atomic_llong* __obj, long long __desr,
                      memory_order __o)
{
    __atomic_store(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(atomic_llong* __obj, long long __desr,
                      memory_order __o)
{
    atomic_store_explicit(const_cast<volatile atomic_llong*>(__obj), __desr,
                                                                           __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_load(const volatile atomic_llong* __obj)
{
    return __atomic_load(&__obj->__v_, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_load(const atomic_llong* __obj)
{
    return atomic_load(const_cast<const volatile atomic_llong*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_load_explicit(const volatile atomic_llong* __obj, memory_order __o)
{
    return __atomic_load(&__obj->__v_, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_load_explicit(const atomic_llong* __obj, memory_order __o)
{
    return atomic_load_explicit(const_cast<const volatile atomic_llong*>
                                                                  (__obj), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_exchange(volatile atomic_llong* __obj, long long __desr)
{
    return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_exchange(atomic_llong* __obj, long long __desr)
{
    return atomic_exchange(const_cast<volatile atomic_llong*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_exchange_explicit(volatile atomic_llong* __obj, long long __desr,
                         memory_order __o)
{
    return __atomic_exchange(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_exchange_explicit(atomic_llong* __obj, long long __desr,
                         memory_order __o)
{
    return atomic_exchange_explicit(const_cast<volatile atomic_llong*>
                                                          (__obj), __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(volatile atomic_llong* __obj, long long* __exp,
                             long long __desr)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(atomic_llong* __obj, long long* __exp,
                             long long __desr)
{
    return atomic_compare_exchange_weak(const_cast<volatile atomic_llong*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(volatile atomic_llong* __obj,
                               long long* __exp, long long __desr)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(atomic_llong* __obj, long long* __exp,
                               long long __desr)
{
    return atomic_compare_exchange_strong(const_cast<volatile atomic_llong*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(volatile atomic_llong* __obj,
                                      long long* __exp,
                                      long long __desr, memory_order __s,
                                      memory_order __f)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(atomic_llong* __obj, long long* __exp,
                                      long long __desr, memory_order __s,
                                      memory_order __f)
{
    return atomic_compare_exchange_weak_explicit(
             const_cast<volatile atomic_llong*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(volatile atomic_llong* __obj,
                                        long long* __exp,
                                        long long __desr, memory_order __s,
                                        memory_order __f)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(atomic_llong* __obj,
                                        long long* __exp,
                                        long long __desr, memory_order __s,
                                        memory_order __f)
{
    return atomic_compare_exchange_strong_explicit(
             const_cast<volatile atomic_llong*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_add(volatile atomic_llong* __obj, long long __v)
{
    return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_add(atomic_llong* __obj, long long __v)
{
    return atomic_fetch_add(const_cast<volatile atomic_llong*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_add_explicit(volatile atomic_llong* __obj, long long __v,
                          memory_order __o)
{
    return __atomic_fetch_add(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_add_explicit(atomic_llong* __obj, long long __v,
                          memory_order __o)
{
    return atomic_fetch_add_explicit(const_cast<volatile atomic_llong*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_sub(volatile atomic_llong* __obj, long long __v)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_sub(atomic_llong* __obj, long long __v)
{
    return atomic_fetch_sub(const_cast<volatile atomic_llong*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_sub_explicit(volatile atomic_llong* __obj, long long __v,
                          memory_order __o)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_sub_explicit(atomic_llong* __obj, long long __v,
                          memory_order __o)
{
    return atomic_fetch_sub_explicit(const_cast<volatile atomic_llong*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_and(volatile atomic_llong* __obj, long long __v)
{
    return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_and(atomic_llong* __obj, long long __v)
{
    return atomic_fetch_and(const_cast<volatile atomic_llong*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_and_explicit(volatile atomic_llong* __obj, long long __v,
                          memory_order __o)
{
    return __atomic_fetch_and(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_and_explicit(atomic_llong* __obj, long long __v,
                          memory_order __o)
{
    return atomic_fetch_and_explicit(const_cast<volatile atomic_llong*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_or(volatile atomic_llong* __obj, long long __v)
{
    return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_or(atomic_llong* __obj, long long __v)
{
    return atomic_fetch_or(const_cast<volatile atomic_llong*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_or_explicit(volatile atomic_llong* __obj, long long __v,
                         memory_order __o)
{
    return __atomic_fetch_or(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_or_explicit(atomic_llong* __obj, long long __v,
                         memory_order __o)
{
    return atomic_fetch_or_explicit(const_cast<volatile atomic_llong*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_xor(volatile atomic_llong* __obj, long long __v)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_xor(atomic_llong* __obj, long long __v)
{
    return atomic_fetch_xor(const_cast<volatile atomic_llong*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_xor_explicit(volatile atomic_llong* __obj, long long __v,
                          memory_order __o)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
long long
atomic_fetch_xor_explicit(atomic_llong* __obj, long long __v,
                          memory_order __o)
{
    return atomic_fetch_xor_explicit(const_cast<volatile atomic_llong*>(__obj),
                                                                      __v, __o);
}

// atomic_ullong

struct atomic_ullong;

bool atomic_is_lock_free(const volatile atomic_ullong*);
bool atomic_is_lock_free(const atomic_ullong*);
void atomic_init(volatile atomic_ullong*, unsigned long long);
void atomic_init(atomic_ullong*, unsigned long long);
void atomic_store(volatile atomic_ullong*, unsigned long long);
void atomic_store(atomic_ullong*, unsigned long long);
void atomic_store_explicit(volatile atomic_ullong*, unsigned long long,
                           memory_order);
void atomic_store_explicit(atomic_ullong*, unsigned long long, memory_order);
unsigned long long atomic_load(const volatile atomic_ullong*);
unsigned long long atomic_load(const atomic_ullong*);
unsigned long long atomic_load_explicit(const volatile atomic_ullong*,
                                        memory_order);
unsigned long long atomic_load_explicit(const atomic_ullong*, memory_order);
unsigned long long atomic_exchange(volatile atomic_ullong*, unsigned long long);
unsigned long long atomic_exchange(atomic_ullong*, unsigned long long);
unsigned long long atomic_exchange_explicit(volatile atomic_ullong*,
                                            unsigned long long, memory_order);
unsigned long long atomic_exchange_explicit(atomic_ullong*, unsigned long long,
                                            memory_order);
bool atomic_compare_exchange_weak(volatile atomic_ullong*, unsigned long long*,
                                  unsigned long long);
bool atomic_compare_exchange_weak(atomic_ullong*, unsigned long long*,
                                  unsigned long long);
bool atomic_compare_exchange_strong(volatile atomic_ullong*,
                                    unsigned long long*, unsigned long long);
bool atomic_compare_exchange_strong(atomic_ullong*, unsigned long long*,
                                    unsigned long long);
bool atomic_compare_exchange_weak_explicit(volatile atomic_ullong*,
                                           unsigned long long*,
                                           unsigned long long,
                                           memory_order, memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_ullong*, unsigned long long*,
                                           unsigned long long, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_ullong*,
                                             unsigned long long*,
                                             unsigned long long,
                                             memory_order, memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_ullong*,
                                             unsigned long long*,
                                             unsigned long long, memory_order,
                                             memory_order);
unsigned long long atomic_fetch_add(volatile atomic_ullong*,
                                    unsigned long long);
unsigned long long atomic_fetch_add(atomic_ullong*, unsigned long long);
unsigned long long atomic_fetch_add_explicit(volatile atomic_ullong*,
                                             unsigned long long, memory_order);
unsigned long long atomic_fetch_add_explicit(atomic_ullong*, unsigned long long,
                                             memory_order);
unsigned long long atomic_fetch_sub(volatile atomic_ullong*,
                                    unsigned long long);
unsigned long long atomic_fetch_sub(atomic_ullong*, unsigned long long);
unsigned long long atomic_fetch_sub_explicit(volatile atomic_ullong*,
                                             unsigned long long, memory_order);
unsigned long long atomic_fetch_sub_explicit(atomic_ullong*, unsigned long long,
                                             memory_order);
unsigned long long atomic_fetch_and(volatile atomic_ullong*, unsigned long long);
unsigned long long atomic_fetch_and(atomic_ullong*, unsigned long long);
unsigned long long atomic_fetch_and_explicit(volatile atomic_ullong*,
                                             unsigned long long, memory_order);
unsigned long long atomic_fetch_and_explicit(atomic_ullong*, unsigned long long,
                                             memory_order);
unsigned long long atomic_fetch_or(volatile atomic_ullong*, unsigned long long);
unsigned long long atomic_fetch_or(atomic_ullong*, unsigned long long);
unsigned long long atomic_fetch_or_explicit(volatile atomic_ullong*,
                                            unsigned long long, memory_order);
unsigned long long atomic_fetch_or_explicit(atomic_ullong*, unsigned long long,
                                            memory_order);
unsigned long long atomic_fetch_xor(volatile atomic_ullong*,
                                    unsigned long long);
unsigned long long atomic_fetch_xor(atomic_ullong*, unsigned long long);
unsigned long long atomic_fetch_xor_explicit(volatile atomic_ullong*,
                                             unsigned long long, memory_order);
unsigned long long atomic_fetch_xor_explicit(atomic_ullong*, unsigned long long,
                                             memory_order);

typedef struct atomic_ullong
{
    unsigned long long __v_;

    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const volatile
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    void store(unsigned long long __v,
               memory_order __o = memory_order_seq_cst) volatile
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void store(unsigned long long __v, memory_order __o = memory_order_seq_cst)
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long load(memory_order __o = memory_order_seq_cst) const
                                                                        volatile
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long load(memory_order __o = memory_order_seq_cst) const
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    operator unsigned long long() const volatile
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    operator unsigned long long() const
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long exchange(unsigned long long __v,
                           memory_order __o = memory_order_seq_cst) volatile
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long exchange(unsigned long long __v,
                           memory_order __o = memory_order_seq_cst)
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned long long& __v, unsigned long long __e,
                               memory_order __s, memory_order __f) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned long long& __v, unsigned long long __e,
                               memory_order __s, memory_order __f)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned long long& __v, unsigned long long __e,
                                 memory_order __s, memory_order __f) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned long long& __v, unsigned long long __e,
                                 memory_order __s, memory_order __f)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned long long& __v, unsigned long long __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(unsigned long long& __v, unsigned long long __e,
                               memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned long long& __v, unsigned long long __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(unsigned long long& __v, unsigned long long __e,
                                 memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long fetch_add(unsigned long long __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long fetch_add(unsigned long long __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long fetch_sub(unsigned long long __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long fetch_sub(unsigned long long __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long fetch_and(unsigned long long __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long fetch_and(unsigned long long __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long fetch_or(unsigned long long __v,
                           memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long fetch_or(unsigned long long __v,
                           memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long fetch_xor(unsigned long long __v,
                            memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_xor_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long fetch_xor(unsigned long long __v,
                            memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_xor_explicit(this, __v, __o);}
#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_ullong() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_ullong() {}
#endif
    _LIBCPP_INLINE_VISIBILITY
    /*constexpr*/ atomic_ullong(unsigned long long __v)
        : __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_ullong(const atomic_ullong&) = delete;
    atomic_ullong& operator=(const atomic_ullong&) = delete;
    atomic_ullong& operator=(const atomic_ullong&) volatile = delete;
#else
private:
    atomic_ullong(const atomic_ullong&);
    atomic_ullong& operator=(const atomic_ullong&);
    atomic_ullong& operator=(const atomic_ullong&) volatile;
public:
#endif
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long operator=(unsigned long long __v) volatile
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long operator=(unsigned long long __v)
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    unsigned long long operator++(int) volatile
        {typedef unsigned long long type; return fetch_add(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator++(int)
        {typedef unsigned long long type; return fetch_add(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator--(int) volatile
        {typedef unsigned long long type; return fetch_sub(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator--(int)
        {typedef unsigned long long type; return fetch_sub(type(1));}
    _LIBCPP_INLINE_VISIBILITY
    long operator++() volatile
        {typedef unsigned long long type; return type(fetch_add(type(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator++()
        {typedef unsigned long long type; return type(fetch_add(type(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator--() volatile
        {typedef unsigned long long type; return type(fetch_sub(type(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator--()
        {typedef unsigned long long type; return type(fetch_sub(type(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    long operator+=(long __v) volatile
        {typedef unsigned long long type; return type(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator+=(long __v)
        {typedef unsigned long long type; return type(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator-=(long __v) volatile
        {typedef unsigned long long type; return type(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator-=(long __v)
        {typedef unsigned long long type; return type(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator&=(long __v) volatile
        {typedef unsigned long long type; return type(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator&=(long __v)
        {typedef unsigned long long type; return type(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator|=(long __v) volatile
        {typedef unsigned long long type; return type(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator|=(long __v)
        {typedef unsigned long long type; return type(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator^=(long __v) volatile
        {typedef unsigned long long type; return type(fetch_xor(__v) ^ __v);}
    _LIBCPP_INLINE_VISIBILITY
    long operator^=(long __v)
        {typedef unsigned long long type; return type(fetch_xor(__v) ^ __v);}
} atomic_ullong;

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const volatile atomic_ullong*)
{
    typedef unsigned long long type;
    return __atomic_is_lock_free(type);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const atomic_ullong* __obj)
{
    return atomic_is_lock_free(const_cast<volatile atomic_ullong*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(volatile atomic_ullong* __obj, unsigned long long __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(atomic_ullong* __obj, unsigned long long __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(volatile atomic_ullong* __obj, unsigned long long __desr)
{
    __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(atomic_ullong* __obj, unsigned long long __desr)
{
    atomic_store(const_cast<volatile atomic_ullong*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(volatile atomic_ullong* __obj, unsigned long long __desr,
                      memory_order __o)
{
    __atomic_store(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(atomic_ullong* __obj, unsigned long long __desr,
                      memory_order __o)
{
    atomic_store_explicit(const_cast<volatile atomic_ullong*>(__obj), __desr,
                                                                           __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_load(const volatile atomic_ullong* __obj)
{
    return __atomic_load(&__obj->__v_, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_load(const atomic_ullong* __obj)
{
    return atomic_load(const_cast<const volatile atomic_ullong*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_load_explicit(const volatile atomic_ullong* __obj, memory_order __o)
{
    return __atomic_load(&__obj->__v_, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_load_explicit(const atomic_ullong* __obj, memory_order __o)
{
    return atomic_load_explicit(const_cast<const volatile atomic_ullong*>
                                                                  (__obj), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_exchange(volatile atomic_ullong* __obj, unsigned long long __desr)
{
    return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_exchange(atomic_ullong* __obj, unsigned long long __desr)
{
    return atomic_exchange(const_cast<volatile atomic_ullong*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_exchange_explicit(volatile atomic_ullong* __obj,
                         unsigned long long __desr, memory_order __o)
{
    return __atomic_exchange(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_exchange_explicit(atomic_ullong* __obj, unsigned long long __desr,
                         memory_order __o)
{
    return atomic_exchange_explicit(const_cast<volatile atomic_ullong*>
                                                          (__obj), __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(volatile atomic_ullong* __obj,
                             unsigned long long* __exp,
                             unsigned long long __desr)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(atomic_ullong* __obj, unsigned long long* __exp,
                             unsigned long long __desr)
{
    return atomic_compare_exchange_weak(const_cast<volatile atomic_ullong*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(volatile atomic_ullong* __obj,
                               unsigned long long* __exp,
                               unsigned long long __desr)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(atomic_ullong* __obj, unsigned long long* __exp,
                               unsigned long long __desr)
{
    return atomic_compare_exchange_strong(const_cast<volatile atomic_ullong*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(volatile atomic_ullong* __obj,
                                      unsigned long long* __exp,
                                      unsigned long long __desr,
                                      memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(atomic_ullong* __obj,
                                      unsigned long long* __exp,
                                      unsigned long long __desr,
                                      memory_order __s, memory_order __f)
{
    return atomic_compare_exchange_weak_explicit(
             const_cast<volatile atomic_ullong*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(volatile atomic_ullong* __obj,
                                        unsigned long long* __exp,
                                        unsigned long long __desr,
                                        memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(atomic_ullong* __obj,
                                        unsigned long long* __exp,
                                        unsigned long long __desr,
                                        memory_order __s, memory_order __f)
{
    return atomic_compare_exchange_strong_explicit(
             const_cast<volatile atomic_ullong*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_add(volatile atomic_ullong* __obj, unsigned long long __v)
{
    return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_add(atomic_ullong* __obj, unsigned long long __v)
{
    return atomic_fetch_add(const_cast<volatile atomic_ullong*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_add_explicit(volatile atomic_ullong* __obj, unsigned long long __v,
                          memory_order __o)
{
    return __atomic_fetch_add(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_add_explicit(atomic_ullong* __obj, unsigned long long __v,
                          memory_order __o)
{
    return atomic_fetch_add_explicit(const_cast<volatile atomic_ullong*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_sub(volatile atomic_ullong* __obj, unsigned long long __v)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_sub(atomic_ullong* __obj, unsigned long long __v)
{
    return atomic_fetch_sub(const_cast<volatile atomic_ullong*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_sub_explicit(volatile atomic_ullong* __obj, unsigned long long __v,
                          memory_order __o)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_sub_explicit(atomic_ullong* __obj, unsigned long long __v,
                          memory_order __o)
{
    return atomic_fetch_sub_explicit(const_cast<volatile atomic_ullong*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_and(volatile atomic_ullong* __obj, unsigned long long __v)
{
    return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_and(atomic_ullong* __obj, unsigned long long __v)
{
    return atomic_fetch_and(const_cast<volatile atomic_ullong*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_and_explicit(volatile atomic_ullong* __obj, unsigned long long __v,
                          memory_order __o)
{
    return __atomic_fetch_and(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_and_explicit(atomic_ullong* __obj, unsigned long long __v,
                          memory_order __o)
{
    return atomic_fetch_and_explicit(const_cast<volatile atomic_ullong*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_or(volatile atomic_ullong* __obj, unsigned long long __v)
{
    return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_or(atomic_ullong* __obj, unsigned long long __v)
{
    return atomic_fetch_or(const_cast<volatile atomic_ullong*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_or_explicit(volatile atomic_ullong* __obj, unsigned long long __v,
                         memory_order __o)
{
    return __atomic_fetch_or(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_or_explicit(atomic_ullong* __obj, unsigned long long __v,
                         memory_order __o)
{
    return atomic_fetch_or_explicit(const_cast<volatile atomic_ullong*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_xor(volatile atomic_ullong* __obj, unsigned long long __v)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_xor(atomic_ullong* __obj, unsigned long long __v)
{
    return atomic_fetch_xor(const_cast<volatile atomic_ullong*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_xor_explicit(volatile atomic_ullong* __obj, unsigned long long __v,
                          memory_order __o)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
unsigned long long
atomic_fetch_xor_explicit(atomic_ullong* __obj, unsigned long long __v,
                          memory_order __o)
{
    return atomic_fetch_xor_explicit(const_cast<volatile atomic_ullong*>(__obj),
                                                                      __v, __o);
}

#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS

// atomic_char16_t

struct atomic_char16_t;

bool atomic_is_lock_free(const volatile atomic_char16_t*);
bool atomic_is_lock_free(const atomic_char16_t*);
void atomic_init(volatile atomic_char16_t*, char16_t);
void atomic_init(atomic_char16_t*, char16_t);
void atomic_store(volatile atomic_char16_t*, char16_t);
void atomic_store(atomic_char16_t*, char16_t);
void atomic_store_explicit(volatile atomic_char16_t*, char16_t, memory_order);
void atomic_store_explicit(atomic_char16_t*, char16_t, memory_order);
char16_t atomic_load(const volatile atomic_char16_t*);
char16_t atomic_load(const atomic_char16_t*);
char16_t atomic_load_explicit(const volatile atomic_char16_t*, memory_order);
char16_t atomic_load_explicit(const atomic_char16_t*, memory_order);
char16_t atomic_exchange(volatile atomic_char16_t*, char16_t);
char16_t atomic_exchange(atomic_char16_t*, char16_t);
char16_t atomic_exchange_explicit(volatile atomic_char16_t*, char16_t,
                                  memory_order);
char16_t atomic_exchange_explicit(atomic_char16_t*, char16_t, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_char16_t*, char16_t*,
                                  char16_t);
bool atomic_compare_exchange_weak(atomic_char16_t*, char16_t*, char16_t);
bool atomic_compare_exchange_strong(volatile atomic_char16_t*, char16_t*,
                                    char16_t);
bool atomic_compare_exchange_strong(atomic_char16_t*, char16_t*, char16_t);
bool atomic_compare_exchange_weak_explicit(volatile atomic_char16_t*, char16_t*,
                                           char16_t, memory_order,
                                           memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_char16_t*, char16_t*,
                                           char16_t, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_char16_t*,
                                             char16_t*, char16_t, memory_order,
                                             memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_char16_t*, char16_t*,
                                             char16_t, memory_order,
                                             memory_order);
char16_t atomic_fetch_add(volatile atomic_char16_t*, char16_t);
char16_t atomic_fetch_add(atomic_char16_t*, char16_t);
char16_t atomic_fetch_add_explicit(volatile atomic_char16_t*, char16_t,
                                   memory_order);
char16_t atomic_fetch_add_explicit(atomic_char16_t*, char16_t, memory_order);
char16_t atomic_fetch_sub(volatile atomic_char16_t*, char16_t);
char16_t atomic_fetch_sub(atomic_char16_t*, char16_t);
char16_t atomic_fetch_sub_explicit(volatile atomic_char16_t*, char16_t,
                                   memory_order);
char16_t atomic_fetch_sub_explicit(atomic_char16_t*, char16_t, memory_order);
char16_t atomic_fetch_and(volatile atomic_char16_t*, char16_t);
char16_t atomic_fetch_and(atomic_char16_t*, char16_t);
char16_t atomic_fetch_and_explicit(volatile atomic_char16_t*, char16_t,
                                   memory_order);
char16_t atomic_fetch_and_explicit(atomic_char16_t*, char16_t, memory_order);
char16_t atomic_fetch_or(volatile atomic_char16_t*, char16_t);
char16_t atomic_fetch_or(atomic_char16_t*, char16_t);
char16_t atomic_fetch_or_explicit(volatile atomic_char16_t*, char16_t,
                                  memory_order);
char16_t atomic_fetch_or_explicit(atomic_char16_t*, char16_t, memory_order);
char16_t atomic_fetch_xor(volatile atomic_char16_t*, char16_t);
char16_t atomic_fetch_xor(atomic_char16_t*, char16_t);
char16_t atomic_fetch_xor_explicit(volatile atomic_char16_t*, char16_t,
                                   memory_order);
char16_t atomic_fetch_xor_explicit(atomic_char16_t*, char16_t, memory_order);

typedef struct atomic_char16_t
{
    char16_t __v_;

    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const volatile
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    void store(char16_t __v, memory_order __o = memory_order_seq_cst) volatile
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void store(char16_t __v, memory_order __o = memory_order_seq_cst)
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t load(memory_order __o = memory_order_seq_cst) const volatile
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t load(memory_order __o = memory_order_seq_cst) const
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    operator char16_t() const volatile
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    operator char16_t() const
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    char16_t exchange(char16_t __v,
                      memory_order __o = memory_order_seq_cst) volatile
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t exchange(char16_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(char16_t& __v, char16_t __e, memory_order __s,
                               memory_order __f) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(char16_t& __v, char16_t __e, memory_order __s,
                               memory_order __f)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(char16_t& __v, char16_t __e, memory_order __s,
                                 memory_order __f) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(char16_t& __v, char16_t __e, memory_order __s,
                                 memory_order __f)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(char16_t& __v, char16_t __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(char16_t& __v, char16_t __e,
                               memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(char16_t& __v, char16_t __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(char16_t& __v, char16_t __e,
                                 memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    char16_t fetch_add(char16_t __v,
                       memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t fetch_add(char16_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t fetch_sub(char16_t __v,
                       memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t fetch_sub(char16_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t fetch_and(char16_t __v,
                       memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t fetch_and(char16_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t fetch_or(char16_t __v,
                      memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t fetch_or(char16_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t fetch_xor(char16_t __v,
                       memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_xor_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t fetch_xor(char16_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_xor_explicit(this, __v, __o);}
#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_char16_t() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_char16_t() {}
#endif
    _LIBCPP_INLINE_VISIBILITY
    /*constexpr*/ atomic_char16_t(char16_t __v)
        : __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_char16_t(const atomic_char16_t&) = delete;
    atomic_char16_t& operator=(const atomic_char16_t&) = delete;
    atomic_char16_t& operator=(const atomic_char16_t&) volatile = delete;
#else
private:
    atomic_char16_t(const atomic_char16_t&);
    atomic_char16_t& operator=(const atomic_char16_t&);
    atomic_char16_t& operator=(const atomic_char16_t&) volatile;
public:
#endif
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator=(char16_t __v) volatile
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator=(char16_t __v)
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator++(int) volatile
        {return fetch_add(char16_t(1));}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator++(int)
        {return fetch_add(char16_t(1));}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator--(int) volatile
        {return fetch_sub(char16_t(1));}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator--(int)
        {return fetch_sub(char16_t(1));}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator++() volatile
        {return char16_t(fetch_add(char16_t(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator++()
        {return char16_t(fetch_add(char16_t(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator--() volatile
        {return char16_t(fetch_sub(char16_t(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator--()
        {return char16_t(fetch_sub(char16_t(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator+=(char16_t __v) volatile
        {return char16_t(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator+=(char16_t __v)
        {return char16_t(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator-=(char16_t __v) volatile
        {return char16_t(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator-=(char16_t __v)
        {return char16_t(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator&=(char16_t __v) volatile
        {return char16_t(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator&=(char16_t __v)
        {return char16_t(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator|=(char16_t __v) volatile
        {return char16_t(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator|=(char16_t __v)
        {return char16_t(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator^=(char16_t __v) volatile
        {return char16_t(fetch_xor(__v) ^ __v);}
    _LIBCPP_INLINE_VISIBILITY
    char16_t operator^=(char16_t __v)
        {return char16_t(fetch_xor(__v) ^ __v);}
} atomic_char16_t;

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const volatile atomic_char16_t*)
{
    typedef char16_t type;
    return __atomic_is_lock_free(type);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const atomic_char16_t* __obj)
{
    return atomic_is_lock_free(const_cast<volatile atomic_char16_t*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(volatile atomic_char16_t* __obj, char16_t __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(atomic_char16_t* __obj, char16_t __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(volatile atomic_char16_t* __obj, char16_t __desr)
{
    __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(atomic_char16_t* __obj, char16_t __desr)
{
    atomic_store(const_cast<volatile atomic_char16_t*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(volatile atomic_char16_t* __obj, char16_t __desr,
                      memory_order __o)
{
    __atomic_store(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(atomic_char16_t* __obj, char16_t __desr, memory_order __o)
{
    atomic_store_explicit(const_cast<volatile atomic_char16_t*>(__obj), __desr,
                                                                           __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_load(const volatile atomic_char16_t* __obj)
{
    return __atomic_load(&__obj->__v_, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_load(const atomic_char16_t* __obj)
{
    return atomic_load(const_cast<const volatile atomic_char16_t*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_load_explicit(const volatile atomic_char16_t* __obj, memory_order __o)
{
    return __atomic_load(&__obj->__v_, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_load_explicit(const atomic_char16_t* __obj, memory_order __o)
{
    return atomic_load_explicit(const_cast<const volatile atomic_char16_t*>
                                                                  (__obj), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_exchange(volatile atomic_char16_t* __obj, char16_t __desr)
{
    return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_exchange(atomic_char16_t* __obj, char16_t __desr)
{
    return atomic_exchange(const_cast<volatile atomic_char16_t*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_exchange_explicit(volatile atomic_char16_t* __obj, char16_t __desr,
                         memory_order __o)
{
    return __atomic_exchange(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_exchange_explicit(atomic_char16_t* __obj, char16_t __desr,
                         memory_order __o)
{
    return atomic_exchange_explicit(const_cast<volatile atomic_char16_t*>
                                                          (__obj), __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(volatile atomic_char16_t* __obj, char16_t* __exp,
                             char16_t __desr)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(atomic_char16_t* __obj, char16_t* __exp,
                             char16_t __desr)
{
    return atomic_compare_exchange_weak(const_cast<volatile atomic_char16_t*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(volatile atomic_char16_t* __obj, char16_t* __exp,
                               char16_t __desr)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(atomic_char16_t* __obj, char16_t* __exp,
                               char16_t __desr)
{
    return atomic_compare_exchange_strong(const_cast<volatile atomic_char16_t*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(volatile atomic_char16_t* __obj,
                                      char16_t* __exp, char16_t __desr,
                                      memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(atomic_char16_t* __obj, char16_t* __exp,
                                      char16_t __desr, memory_order __s,
                                      memory_order __f)
{
    return atomic_compare_exchange_weak_explicit(
             const_cast<volatile atomic_char16_t*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(volatile atomic_char16_t* __obj,
                                        char16_t* __exp, char16_t __desr,
                                        memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(atomic_char16_t* __obj, char16_t* __exp,
                                        char16_t __desr, memory_order __s,
                                        memory_order __f)
{
    return atomic_compare_exchange_strong_explicit(
             const_cast<volatile atomic_char16_t*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_add(volatile atomic_char16_t* __obj, char16_t __v)
{
    return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_add(atomic_char16_t* __obj, char16_t __v)
{
    return atomic_fetch_add(const_cast<volatile atomic_char16_t*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_add_explicit(volatile atomic_char16_t* __obj, char16_t __v,
                          memory_order __o)
{
    return __atomic_fetch_add(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_add_explicit(atomic_char16_t* __obj, char16_t __v,
                          memory_order __o)
{
    return atomic_fetch_add_explicit(const_cast<volatile atomic_char16_t*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_sub(volatile atomic_char16_t* __obj, char16_t __v)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_sub(atomic_char16_t* __obj, char16_t __v)
{
    return atomic_fetch_sub(const_cast<volatile atomic_char16_t*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_sub_explicit(volatile atomic_char16_t* __obj, char16_t __v,
                          memory_order __o)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_sub_explicit(atomic_char16_t* __obj, char16_t __v,
                          memory_order __o)
{
    return atomic_fetch_sub_explicit(const_cast<volatile atomic_char16_t*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_and(volatile atomic_char16_t* __obj, char16_t __v)
{
    return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_and(atomic_char16_t* __obj, char16_t __v)
{
    return atomic_fetch_and(const_cast<volatile atomic_char16_t*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_and_explicit(volatile atomic_char16_t* __obj, char16_t __v,
                          memory_order __o)
{
    return __atomic_fetch_and(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_and_explicit(atomic_char16_t* __obj, char16_t __v,
                          memory_order __o)
{
    return atomic_fetch_and_explicit(const_cast<volatile atomic_char16_t*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_or(volatile atomic_char16_t* __obj, char16_t __v)
{
    return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_or(atomic_char16_t* __obj, char16_t __v)
{
    return atomic_fetch_or(const_cast<volatile atomic_char16_t*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_or_explicit(volatile atomic_char16_t* __obj, char16_t __v,
                         memory_order __o)
{
    return __atomic_fetch_or(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_or_explicit(atomic_char16_t* __obj, char16_t __v, memory_order __o)
{
    return atomic_fetch_or_explicit(const_cast<volatile atomic_char16_t*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_xor(volatile atomic_char16_t* __obj, char16_t __v)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_xor(atomic_char16_t* __obj, char16_t __v)
{
    return atomic_fetch_xor(const_cast<volatile atomic_char16_t*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_xor_explicit(volatile atomic_char16_t* __obj, char16_t __v,
                          memory_order __o)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char16_t
atomic_fetch_xor_explicit(atomic_char16_t* __obj, char16_t __v,
                          memory_order __o)
{
    return atomic_fetch_xor_explicit(const_cast<volatile atomic_char16_t*>(__obj),
                                                                      __v, __o);
}

// atomic_char32_t

struct atomic_char32_t;

bool atomic_is_lock_free(const volatile atomic_char32_t*);
bool atomic_is_lock_free(const atomic_char32_t*);
void atomic_init(volatile atomic_char32_t*, char32_t);
void atomic_init(atomic_char32_t*, char32_t);
void atomic_store(volatile atomic_char32_t*, char32_t);
void atomic_store(atomic_char32_t*, char32_t);
void atomic_store_explicit(volatile atomic_char32_t*, char32_t, memory_order);
void atomic_store_explicit(atomic_char32_t*, char32_t, memory_order);
char32_t atomic_load(const volatile atomic_char32_t*);
char32_t atomic_load(const atomic_char32_t*);
char32_t atomic_load_explicit(const volatile atomic_char32_t*, memory_order);
char32_t atomic_load_explicit(const atomic_char32_t*, memory_order);
char32_t atomic_exchange(volatile atomic_char32_t*, char32_t);
char32_t atomic_exchange(atomic_char32_t*, char32_t);
char32_t atomic_exchange_explicit(volatile atomic_char32_t*, char32_t,
                                  memory_order);
char32_t atomic_exchange_explicit(atomic_char32_t*, char32_t, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_char32_t*, char32_t*,
                                  char32_t);
bool atomic_compare_exchange_weak(atomic_char32_t*, char32_t*, char32_t);
bool atomic_compare_exchange_strong(volatile atomic_char32_t*, char32_t*,
                                    char32_t);
bool atomic_compare_exchange_strong(atomic_char32_t*, char32_t*, char32_t);
bool atomic_compare_exchange_weak_explicit(volatile atomic_char32_t*, char32_t*,
                                           char32_t, memory_order,
                                           memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_char32_t*, char32_t*,
                                           char32_t, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_char32_t*,
                                             char32_t*, char32_t, memory_order,
                                             memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_char32_t*, char32_t*,
                                             char32_t, memory_order,
                                             memory_order);
char32_t atomic_fetch_add(volatile atomic_char32_t*, char32_t);
char32_t atomic_fetch_add(atomic_char32_t*, char32_t);
char32_t atomic_fetch_add_explicit(volatile atomic_char32_t*, char32_t,
                                   memory_order);
char32_t atomic_fetch_add_explicit(atomic_char32_t*, char32_t, memory_order);
char32_t atomic_fetch_sub(volatile atomic_char32_t*, char32_t);
char32_t atomic_fetch_sub(atomic_char32_t*, char32_t);
char32_t atomic_fetch_sub_explicit(volatile atomic_char32_t*, char32_t,
                                   memory_order);
char32_t atomic_fetch_sub_explicit(atomic_char32_t*, char32_t, memory_order);
char32_t atomic_fetch_and(volatile atomic_char32_t*, char32_t);
char32_t atomic_fetch_and(atomic_char32_t*, char32_t);
char32_t atomic_fetch_and_explicit(volatile atomic_char32_t*, char32_t,
                                   memory_order);
char32_t atomic_fetch_and_explicit(atomic_char32_t*, char32_t, memory_order);
char32_t atomic_fetch_or(volatile atomic_char32_t*, char32_t);
char32_t atomic_fetch_or(atomic_char32_t*, char32_t);
char32_t atomic_fetch_or_explicit(volatile atomic_char32_t*, char32_t,
                                  memory_order);
char32_t atomic_fetch_or_explicit(atomic_char32_t*, char32_t, memory_order);
char32_t atomic_fetch_xor(volatile atomic_char32_t*, char32_t);
char32_t atomic_fetch_xor(atomic_char32_t*, char32_t);
char32_t atomic_fetch_xor_explicit(volatile atomic_char32_t*, char32_t,
                                   memory_order);
char32_t atomic_fetch_xor_explicit(atomic_char32_t*, char32_t, memory_order);

typedef struct atomic_char32_t
{
    char32_t __v_;

    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const volatile
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    void store(char32_t __v, memory_order __o = memory_order_seq_cst) volatile
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void store(char32_t __v, memory_order __o = memory_order_seq_cst)
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t load(memory_order __o = memory_order_seq_cst) const volatile
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t load(memory_order __o = memory_order_seq_cst) const
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    operator char32_t() const volatile
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    operator char32_t() const
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    char32_t exchange(char32_t __v,
                      memory_order __o = memory_order_seq_cst) volatile
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t exchange(char32_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(char32_t& __v, char32_t __e, memory_order __s,
                               memory_order __f) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(char32_t& __v, char32_t __e, memory_order __s,
                               memory_order __f)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(char32_t& __v, char32_t __e, memory_order __s,
                                 memory_order __f) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(char32_t& __v, char32_t __e, memory_order __s,
                                 memory_order __f)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(char32_t& __v, char32_t __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(char32_t& __v, char32_t __e,
                               memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(char32_t& __v, char32_t __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(char32_t& __v, char32_t __e,
                                 memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    char32_t fetch_add(char32_t __v,
                       memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t fetch_add(char32_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t fetch_sub(char32_t __v,
                       memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t fetch_sub(char32_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t fetch_and(char32_t __v,
                       memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t fetch_and(char32_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t fetch_or(char32_t __v,
                      memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t fetch_or(char32_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t fetch_xor(char32_t __v,
                       memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_xor_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t fetch_xor(char32_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_xor_explicit(this, __v, __o);}
#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_char32_t() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_char32_t() {}
#endif
    _LIBCPP_INLINE_VISIBILITY
    /*constexpr*/ atomic_char32_t(char32_t __v)
        : __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_char32_t(const atomic_char32_t&) = delete;
    atomic_char32_t& operator=(const atomic_char32_t&) = delete;
    atomic_char32_t& operator=(const atomic_char32_t&) volatile = delete;
#else
private:
    atomic_char32_t(const atomic_char32_t&);
    atomic_char32_t& operator=(const atomic_char32_t&);
    atomic_char32_t& operator=(const atomic_char32_t&) volatile;
public:
#endif
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator=(char32_t __v) volatile
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator=(char32_t __v)
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator++(int) volatile
        {return fetch_add(char32_t(1));}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator++(int)
        {return fetch_add(char32_t(1));}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator--(int) volatile
        {return fetch_sub(char32_t(1));}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator--(int)
        {return fetch_sub(char32_t(1));}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator++() volatile
        {return char32_t(fetch_add(char32_t(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator++()
        {return char32_t(fetch_add(char32_t(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator--() volatile
        {return char32_t(fetch_sub(char32_t(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator--()
        {return char32_t(fetch_sub(char32_t(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator+=(char32_t __v) volatile
        {return char32_t(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator+=(char32_t __v)
        {return char32_t(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator-=(char32_t __v) volatile
        {return char32_t(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator-=(char32_t __v)
        {return char32_t(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator&=(char32_t __v) volatile
        {return char32_t(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator&=(char32_t __v)
        {return char32_t(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator|=(char32_t __v) volatile
        {return char32_t(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator|=(char32_t __v)
        {return char32_t(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator^=(char32_t __v) volatile
        {return char32_t(fetch_xor(__v) ^ __v);}
    _LIBCPP_INLINE_VISIBILITY
    char32_t operator^=(char32_t __v)
        {return char32_t(fetch_xor(__v) ^ __v);}
} atomic_char32_t;

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const volatile atomic_char32_t*)
{
    typedef char32_t type;
    return __atomic_is_lock_free(type);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const atomic_char32_t* __obj)
{
    return atomic_is_lock_free(const_cast<volatile atomic_char32_t*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(volatile atomic_char32_t* __obj, char32_t __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(atomic_char32_t* __obj, char32_t __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(volatile atomic_char32_t* __obj, char32_t __desr)
{
    __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(atomic_char32_t* __obj, char32_t __desr)
{
    atomic_store(const_cast<volatile atomic_char32_t*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(volatile atomic_char32_t* __obj, char32_t __desr,
                      memory_order __o)
{
    __atomic_store(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(atomic_char32_t* __obj, char32_t __desr, memory_order __o)
{
    atomic_store_explicit(const_cast<volatile atomic_char32_t*>(__obj), __desr,
                                                                           __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_load(const volatile atomic_char32_t* __obj)
{
    return __atomic_load(&__obj->__v_, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_load(const atomic_char32_t* __obj)
{
    return atomic_load(const_cast<const volatile atomic_char32_t*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_load_explicit(const volatile atomic_char32_t* __obj, memory_order __o)
{
    return __atomic_load(&__obj->__v_, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_load_explicit(const atomic_char32_t* __obj, memory_order __o)
{
    return atomic_load_explicit(const_cast<const volatile atomic_char32_t*>
                                                                  (__obj), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_exchange(volatile atomic_char32_t* __obj, char32_t __desr)
{
    return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_exchange(atomic_char32_t* __obj, char32_t __desr)
{
    return atomic_exchange(const_cast<volatile atomic_char32_t*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_exchange_explicit(volatile atomic_char32_t* __obj, char32_t __desr,
                         memory_order __o)
{
    return __atomic_exchange(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_exchange_explicit(atomic_char32_t* __obj, char32_t __desr,
                         memory_order __o)
{
    return atomic_exchange_explicit(const_cast<volatile atomic_char32_t*>
                                                          (__obj), __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(volatile atomic_char32_t* __obj, char32_t* __exp,
                             char32_t __desr)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(atomic_char32_t* __obj, char32_t* __exp,
                             char32_t __desr)
{
    return atomic_compare_exchange_weak(const_cast<volatile atomic_char32_t*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(volatile atomic_char32_t* __obj, char32_t* __exp,
                               char32_t __desr)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(atomic_char32_t* __obj, char32_t* __exp,
                               char32_t __desr)
{
    return atomic_compare_exchange_strong(const_cast<volatile atomic_char32_t*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(volatile atomic_char32_t* __obj,
                                      char32_t* __exp, char32_t __desr,
                                      memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(atomic_char32_t* __obj, char32_t* __exp,
                                      char32_t __desr, memory_order __s,
                                      memory_order __f)
{
    return atomic_compare_exchange_weak_explicit(
             const_cast<volatile atomic_char32_t*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(volatile atomic_char32_t* __obj,
                                        char32_t* __exp, char32_t __desr,
                                        memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(atomic_char32_t* __obj, char32_t* __exp,
                                        char32_t __desr, memory_order __s,
                                        memory_order __f)
{
    return atomic_compare_exchange_strong_explicit(
             const_cast<volatile atomic_char32_t*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_add(volatile atomic_char32_t* __obj, char32_t __v)
{
    return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_add(atomic_char32_t* __obj, char32_t __v)
{
    return atomic_fetch_add(const_cast<volatile atomic_char32_t*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_add_explicit(volatile atomic_char32_t* __obj, char32_t __v,
                          memory_order __o)
{
    return __atomic_fetch_add(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_add_explicit(atomic_char32_t* __obj, char32_t __v,
                          memory_order __o)
{
    return atomic_fetch_add_explicit(const_cast<volatile atomic_char32_t*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_sub(volatile atomic_char32_t* __obj, char32_t __v)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_sub(atomic_char32_t* __obj, char32_t __v)
{
    return atomic_fetch_sub(const_cast<volatile atomic_char32_t*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_sub_explicit(volatile atomic_char32_t* __obj, char32_t __v,
                          memory_order __o)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_sub_explicit(atomic_char32_t* __obj, char32_t __v,
                          memory_order __o)
{
    return atomic_fetch_sub_explicit(const_cast<volatile atomic_char32_t*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_and(volatile atomic_char32_t* __obj, char32_t __v)
{
    return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_and(atomic_char32_t* __obj, char32_t __v)
{
    return atomic_fetch_and(const_cast<volatile atomic_char32_t*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_and_explicit(volatile atomic_char32_t* __obj, char32_t __v,
                          memory_order __o)
{
    return __atomic_fetch_and(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_and_explicit(atomic_char32_t* __obj, char32_t __v,
                          memory_order __o)
{
    return atomic_fetch_and_explicit(const_cast<volatile atomic_char32_t*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_or(volatile atomic_char32_t* __obj, char32_t __v)
{
    return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_or(atomic_char32_t* __obj, char32_t __v)
{
    return atomic_fetch_or(const_cast<volatile atomic_char32_t*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_or_explicit(volatile atomic_char32_t* __obj, char32_t __v,
                         memory_order __o)
{
    return __atomic_fetch_or(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_or_explicit(atomic_char32_t* __obj, char32_t __v, memory_order __o)
{
    return atomic_fetch_or_explicit(const_cast<volatile atomic_char32_t*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_xor(volatile atomic_char32_t* __obj, char32_t __v)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_xor(atomic_char32_t* __obj, char32_t __v)
{
    return atomic_fetch_xor(const_cast<volatile atomic_char32_t*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_xor_explicit(volatile atomic_char32_t* __obj, char32_t __v,
                          memory_order __o)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
char32_t
atomic_fetch_xor_explicit(atomic_char32_t* __obj, char32_t __v,
                          memory_order __o)
{
    return atomic_fetch_xor_explicit(const_cast<volatile atomic_char32_t*>(__obj),
                                                                      __v, __o);
}

#endif  // _LIBCPP_HAS_NO_UNICODE_CHARS

// atomic_wchar_t

struct atomic_wchar_t;

bool atomic_is_lock_free(const volatile atomic_wchar_t*);
bool atomic_is_lock_free(const atomic_wchar_t*);
void atomic_init(volatile atomic_wchar_t*, wchar_t);
void atomic_init(atomic_wchar_t*, wchar_t);
void atomic_store(volatile atomic_wchar_t*, wchar_t);
void atomic_store(atomic_wchar_t*, wchar_t);
void atomic_store_explicit(volatile atomic_wchar_t*, wchar_t, memory_order);
void atomic_store_explicit(atomic_wchar_t*, wchar_t, memory_order);
wchar_t atomic_load(const volatile atomic_wchar_t*);
wchar_t atomic_load(const atomic_wchar_t*);
wchar_t atomic_load_explicit(const volatile atomic_wchar_t*, memory_order);
wchar_t atomic_load_explicit(const atomic_wchar_t*, memory_order);
wchar_t atomic_exchange(volatile atomic_wchar_t*, wchar_t);
wchar_t atomic_exchange(atomic_wchar_t*, wchar_t);
wchar_t atomic_exchange_explicit(volatile atomic_wchar_t*, wchar_t,
                                  memory_order);
wchar_t atomic_exchange_explicit(atomic_wchar_t*, wchar_t, memory_order);
bool atomic_compare_exchange_weak(volatile atomic_wchar_t*, wchar_t*,
                                  wchar_t);
bool atomic_compare_exchange_weak(atomic_wchar_t*, wchar_t*, wchar_t);
bool atomic_compare_exchange_strong(volatile atomic_wchar_t*, wchar_t*,
                                    wchar_t);
bool atomic_compare_exchange_strong(atomic_wchar_t*, wchar_t*, wchar_t);
bool atomic_compare_exchange_weak_explicit(volatile atomic_wchar_t*, wchar_t*,
                                           wchar_t, memory_order,
                                           memory_order);
bool atomic_compare_exchange_weak_explicit(atomic_wchar_t*, wchar_t*,
                                           wchar_t, memory_order,
                                           memory_order);
bool atomic_compare_exchange_strong_explicit(volatile atomic_wchar_t*,
                                             wchar_t*, wchar_t, memory_order,
                                             memory_order);
bool atomic_compare_exchange_strong_explicit(atomic_wchar_t*, wchar_t*,
                                             wchar_t, memory_order,
                                             memory_order);
wchar_t atomic_fetch_add(volatile atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_add(atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_add_explicit(volatile atomic_wchar_t*, wchar_t,
                                   memory_order);
wchar_t atomic_fetch_add_explicit(atomic_wchar_t*, wchar_t, memory_order);
wchar_t atomic_fetch_sub(volatile atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_sub(atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_sub_explicit(volatile atomic_wchar_t*, wchar_t,
                                   memory_order);
wchar_t atomic_fetch_sub_explicit(atomic_wchar_t*, wchar_t, memory_order);
wchar_t atomic_fetch_and(volatile atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_and(atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_and_explicit(volatile atomic_wchar_t*, wchar_t,
                                   memory_order);
wchar_t atomic_fetch_and_explicit(atomic_wchar_t*, wchar_t, memory_order);
wchar_t atomic_fetch_or(volatile atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_or(atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_or_explicit(volatile atomic_wchar_t*, wchar_t,
                                  memory_order);
wchar_t atomic_fetch_or_explicit(atomic_wchar_t*, wchar_t, memory_order);
wchar_t atomic_fetch_xor(volatile atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_xor(atomic_wchar_t*, wchar_t);
wchar_t atomic_fetch_xor_explicit(volatile atomic_wchar_t*, wchar_t,
                                   memory_order);
wchar_t atomic_fetch_xor_explicit(atomic_wchar_t*, wchar_t, memory_order);

typedef struct atomic_wchar_t
{
    wchar_t __v_;

    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const volatile
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    bool is_lock_free() const
        {return atomic_is_lock_free(this);}
    _LIBCPP_INLINE_VISIBILITY
    void store(wchar_t __v, memory_order __o = memory_order_seq_cst) volatile
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    void store(wchar_t __v, memory_order __o = memory_order_seq_cst)
        {atomic_store_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t load(memory_order __o = memory_order_seq_cst) const volatile
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t load(memory_order __o = memory_order_seq_cst) const
        {return atomic_load_explicit(this, __o);}
    _LIBCPP_INLINE_VISIBILITY
    operator wchar_t() const volatile
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    operator wchar_t() const
        {return load();}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t exchange(wchar_t __v,
                      memory_order __o = memory_order_seq_cst) volatile
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t exchange(wchar_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_exchange_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(wchar_t& __v, wchar_t __e, memory_order __s,
                               memory_order __f) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(wchar_t& __v, wchar_t __e, memory_order __s,
                               memory_order __f)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(wchar_t& __v, wchar_t __e, memory_order __s,
                                 memory_order __f) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(wchar_t& __v, wchar_t __e, memory_order __s,
                                 memory_order __f)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                                          __f);}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(wchar_t& __v, wchar_t __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_weak(wchar_t& __v, wchar_t __e,
                               memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_weak_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(wchar_t& __v, wchar_t __e,
                               memory_order __s = memory_order_seq_cst) volatile
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    bool compare_exchange_strong(wchar_t& __v, wchar_t __e,
                                 memory_order __s = memory_order_seq_cst)
        {return atomic_compare_exchange_strong_explicit(this, &__v, __e, __s,
                                                __translate_memory_order(__s));}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t fetch_add(wchar_t __v,
                       memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t fetch_add(wchar_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_add_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t fetch_sub(wchar_t __v,
                       memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t fetch_sub(wchar_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_sub_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t fetch_and(wchar_t __v,
                       memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t fetch_and(wchar_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_and_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t fetch_or(wchar_t __v,
                      memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t fetch_or(wchar_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_or_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t fetch_xor(wchar_t __v,
                       memory_order __o = memory_order_seq_cst) volatile
        {return atomic_fetch_xor_explicit(this, __v, __o);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t fetch_xor(wchar_t __v, memory_order __o = memory_order_seq_cst)
        {return atomic_fetch_xor_explicit(this, __v, __o);}
#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
    atomic_wchar_t() = default;
#else
    _LIBCPP_INLINE_VISIBILITY
    atomic_wchar_t() {}
#endif
    _LIBCPP_INLINE_VISIBILITY
    /*constexpr*/ atomic_wchar_t(wchar_t __v)
        : __v_(__v) {}
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    atomic_wchar_t(const atomic_wchar_t&) = delete;
    atomic_wchar_t& operator=(const atomic_wchar_t&) = delete;
    atomic_wchar_t& operator=(const atomic_wchar_t&) volatile = delete;
#else
private:
    atomic_wchar_t(const atomic_wchar_t&);
    atomic_wchar_t& operator=(const atomic_wchar_t&);
    atomic_wchar_t& operator=(const atomic_wchar_t&) volatile;
public:
#endif
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator=(wchar_t __v) volatile
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator=(wchar_t __v)
        {store(__v); return __v;}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator++(int) volatile
        {return fetch_add(wchar_t(1));}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator++(int)
        {return fetch_add(wchar_t(1));}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator--(int) volatile
        {return fetch_sub(wchar_t(1));}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator--(int)
        {return fetch_sub(wchar_t(1));}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator++() volatile
        {return wchar_t(fetch_add(wchar_t(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator++()
        {return wchar_t(fetch_add(wchar_t(1)) + 1);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator--() volatile
        {return wchar_t(fetch_sub(wchar_t(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator--()
        {return wchar_t(fetch_sub(wchar_t(1)) - 1);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator+=(wchar_t __v) volatile
        {return wchar_t(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator+=(wchar_t __v)
        {return wchar_t(fetch_add(__v) + __v);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator-=(wchar_t __v) volatile
        {return wchar_t(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator-=(wchar_t __v)
        {return wchar_t(fetch_sub(__v) - __v);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator&=(wchar_t __v) volatile
        {return wchar_t(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator&=(wchar_t __v)
        {return wchar_t(fetch_and(__v) & __v);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator|=(wchar_t __v) volatile
        {return wchar_t(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator|=(wchar_t __v)
        {return wchar_t(fetch_or(__v) | __v);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator^=(wchar_t __v) volatile
        {return wchar_t(fetch_xor(__v) ^ __v);}
    _LIBCPP_INLINE_VISIBILITY
    wchar_t operator^=(wchar_t __v)
        {return wchar_t(fetch_xor(__v) ^ __v);}
} atomic_wchar_t;

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const volatile atomic_wchar_t*)
{
    typedef wchar_t type;
    return __atomic_is_lock_free(type);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_is_lock_free(const atomic_wchar_t* __obj)
{
    return atomic_is_lock_free(const_cast<volatile atomic_wchar_t*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(volatile atomic_wchar_t* __obj, wchar_t __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_init(atomic_wchar_t* __obj, wchar_t __desr)
{
    __obj->__v_ = __desr;
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(volatile atomic_wchar_t* __obj, wchar_t __desr)
{
    __atomic_store(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store(atomic_wchar_t* __obj, wchar_t __desr)
{
    atomic_store(const_cast<volatile atomic_wchar_t*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(volatile atomic_wchar_t* __obj, wchar_t __desr,
                      memory_order __o)
{
    __atomic_store(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
void
atomic_store_explicit(atomic_wchar_t* __obj, wchar_t __desr, memory_order __o)
{
    atomic_store_explicit(const_cast<volatile atomic_wchar_t*>(__obj), __desr,
                                                                           __o);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_load(const volatile atomic_wchar_t* __obj)
{
    return __atomic_load(&__obj->__v_, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_load(const atomic_wchar_t* __obj)
{
    return atomic_load(const_cast<const volatile atomic_wchar_t*>(__obj));
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_load_explicit(const volatile atomic_wchar_t* __obj, memory_order __o)
{
    return __atomic_load(&__obj->__v_, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_load_explicit(const atomic_wchar_t* __obj, memory_order __o)
{
    return atomic_load_explicit(const_cast<const volatile atomic_wchar_t*>
                                                                  (__obj), __o);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_exchange(volatile atomic_wchar_t* __obj, wchar_t __desr)
{
    return __atomic_exchange(&__obj->__v_, __desr, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_exchange(atomic_wchar_t* __obj, wchar_t __desr)
{
    return atomic_exchange(const_cast<volatile atomic_wchar_t*>(__obj), __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_exchange_explicit(volatile atomic_wchar_t* __obj, wchar_t __desr,
                         memory_order __o)
{
    return __atomic_exchange(&__obj->__v_, __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_exchange_explicit(atomic_wchar_t* __obj, wchar_t __desr,
                         memory_order __o)
{
    return atomic_exchange_explicit(const_cast<volatile atomic_wchar_t*>
                                                          (__obj), __desr, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(volatile atomic_wchar_t* __obj, wchar_t* __exp,
                             wchar_t __desr)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak(atomic_wchar_t* __obj, wchar_t* __exp,
                             wchar_t __desr)
{
    return atomic_compare_exchange_weak(const_cast<volatile atomic_wchar_t*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(volatile atomic_wchar_t* __obj, wchar_t* __exp,
                               wchar_t __desr)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr,
                                    memory_order_seq_cst, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong(atomic_wchar_t* __obj, wchar_t* __exp,
                               wchar_t __desr)
{
    return atomic_compare_exchange_strong(const_cast<volatile atomic_wchar_t*>
                                                        (__obj), __exp, __desr);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(volatile atomic_wchar_t* __obj,
                                      wchar_t* __exp, wchar_t __desr,
                                      memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_weak(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_weak_explicit(atomic_wchar_t* __obj, wchar_t* __exp,
                                      wchar_t __desr, memory_order __s,
                                      memory_order __f)
{
    return atomic_compare_exchange_weak_explicit(
             const_cast<volatile atomic_wchar_t*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(volatile atomic_wchar_t* __obj,
                                        wchar_t* __exp, wchar_t __desr,
                                        memory_order __s, memory_order __f)
{
    return __atomic_compare_exchange_strong(&__obj->__v_, __exp, __desr, __s,
                                                                           __f);
}

inline _LIBCPP_INLINE_VISIBILITY
bool
atomic_compare_exchange_strong_explicit(atomic_wchar_t* __obj, wchar_t* __exp,
                                        wchar_t __desr, memory_order __s,
                                        memory_order __f)
{
    return atomic_compare_exchange_strong_explicit(
             const_cast<volatile atomic_wchar_t*>(__obj), __exp, __desr, __s, __f);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_add(volatile atomic_wchar_t* __obj, wchar_t __v)
{
    return __atomic_fetch_add(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_add(atomic_wchar_t* __obj, wchar_t __v)
{
    return atomic_fetch_add(const_cast<volatile atomic_wchar_t*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_add_explicit(volatile atomic_wchar_t* __obj, wchar_t __v,
                          memory_order __o)
{
    return __atomic_fetch_add(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_add_explicit(atomic_wchar_t* __obj, wchar_t __v,
                          memory_order __o)
{
    return atomic_fetch_add_explicit(const_cast<volatile atomic_wchar_t*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_sub(volatile atomic_wchar_t* __obj, wchar_t __v)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_sub(atomic_wchar_t* __obj, wchar_t __v)
{
    return atomic_fetch_sub(const_cast<volatile atomic_wchar_t*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_sub_explicit(volatile atomic_wchar_t* __obj, wchar_t __v,
                          memory_order __o)
{
    return __atomic_fetch_sub(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_sub_explicit(atomic_wchar_t* __obj, wchar_t __v,
                          memory_order __o)
{
    return atomic_fetch_sub_explicit(const_cast<volatile atomic_wchar_t*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_and(volatile atomic_wchar_t* __obj, wchar_t __v)
{
    return __atomic_fetch_and(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_and(atomic_wchar_t* __obj, wchar_t __v)
{
    return atomic_fetch_and(const_cast<volatile atomic_wchar_t*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_and_explicit(volatile atomic_wchar_t* __obj, wchar_t __v,
                          memory_order __o)
{
    return __atomic_fetch_and(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_and_explicit(atomic_wchar_t* __obj, wchar_t __v,
                          memory_order __o)
{
    return atomic_fetch_and_explicit(const_cast<volatile atomic_wchar_t*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_or(volatile atomic_wchar_t* __obj, wchar_t __v)
{
    return __atomic_fetch_or(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_or(atomic_wchar_t* __obj, wchar_t __v)
{
    return atomic_fetch_or(const_cast<volatile atomic_wchar_t*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_or_explicit(volatile atomic_wchar_t* __obj, wchar_t __v,
                         memory_order __o)
{
    return __atomic_fetch_or(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_or_explicit(atomic_wchar_t* __obj, wchar_t __v, memory_order __o)
{
    return atomic_fetch_or_explicit(const_cast<volatile atomic_wchar_t*>(__obj),
                                                                      __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_xor(volatile atomic_wchar_t* __obj, wchar_t __v)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, memory_order_seq_cst);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_xor(atomic_wchar_t* __obj, wchar_t __v)
{
    return atomic_fetch_xor(const_cast<volatile atomic_wchar_t*>(__obj), __v);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_xor_explicit(volatile atomic_wchar_t* __obj, wchar_t __v,
                          memory_order __o)
{
    return __atomic_fetch_xor(&__obj->__v_, __v, __o);
}

inline _LIBCPP_INLINE_VISIBILITY
wchar_t
atomic_fetch_xor_explicit(atomic_wchar_t* __obj, wchar_t __v,
                          memory_order __o)
{
    return atomic_fetch_xor_explicit(const_cast<volatile atomic_wchar_t*>(__obj),
                                                                      __v, __o);
}

_LIBCPP_END_NAMESPACE_STD

#endif  // _LIBCPP_ATOMIC