meta_type.h

// Evaluates to whether the arguments' types are compatible.
// Bounded array types are considered incompatible with unbounded array types.
#define meta_is_same_type(X, ...) _Generic(typeof(X),typeof(__VA_ARGS__):meta_is_unbounded_array_type(X)==meta_is_unbounded_array_type(__VA_ARGS__),default:0)

// Evaluates to whether the arguments' types are compatible, ignoring qualifiers.
// Bounded array types are considered incompatible with unbounded array types.
#define meta_is_same_type_unqual(X, ...) _Generic(typeof_unqual(X),typeof_unqual(__VA_ARGS__):meta_is_unbounded_array_type(X)==meta_is_unbounded_array_type(__VA_ARGS__),default:0)

// Accepts a condition expression and two other expressions.
// The condition must be constant and integer-like.
// If the condition is truthy, evaluates to the second expression.
// Otherwise, evaluates to the third expression.
#define meta_choose_expr(COND, X, ...) _Generic(int[1+!(COND)],int[1]:(X),default:(__VA_ARGS__))

// Accepts a condition expression and two other types or expressions.
// The condition must be constant and integer-like.
// If the condition is truthy, evaluates to the second argument's type.
// Otherwise, evaluates to the third argument's type.
#define meta_choose_type(COND, X, ...) typeof(meta_choose_expr((COND),meta_fake(X),meta_fake(__VA_ARGS__)))

// Evaluates to an lvalue expression of the argument's type.
// Must not be used in evaluated contexts.
#define meta_fake(...) (*(typeof(__VA_ARGS__)*)0)

// Evaluates to an lvalue expression of the argument's type, ignoring qualifiers.
// Must not be used in evaluated contexts.
#define meta_fake_unqual(...) (*(typeof_unqual(__VA_ARGS__)*)0)

// Evaluates to whether the argument's type is a function type.
// Function pointer types are not considered to be function types.
#define meta_is_function_type(...) _Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:1,default:0)

// Evaluates to whether the argument's type is an array type.
#define meta_is_array_type(...) _Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:!meta_is_decayed_type(__VA_ARGS__))

// Evaluates to whether the argument's type is a bounded array type.
#define meta_is_bounded_array_type(...) _Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:_Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):0,default:!meta_is_unbounded_array_type(__VA_ARGS__)))

// Evaluates to whether the argument's type is an unbounded array type.
#define meta_is_unbounded_array_type(...) _Generic(typeof(__VA_ARGS__),typeof(*_Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):(int*)0,default:_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:(int*)0,default:meta_fake(__VA_ARGS__))))[1]:_Generic(typeof(__VA_ARGS__),typeof(*_Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):(int*)0,default:_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:(int*)0,default:meta_fake(__VA_ARGS__))))[2]:1,default:0),default:0)

// If the argument's type is a bounded array type, evaluates to the array's size.
// Otherwise, evaluates to zero.
#define meta_array_extent(...) (sizeof(meta_choose_expr(meta_is_bounded_array_type(__VA_ARGS__),meta_fake(__VA_ARGS__),0))/sizeof(*meta_fake(meta_choose_type(meta_is_bounded_array_type(__VA_ARGS__),typeof(__VA_ARGS__),int(*)[2]))))

// If the argument's type is an array type, evaluates to the array's value type.
// Otherwise, evaluates to void.
#define meta_array_value_type(...) meta_choose_type(meta_is_array_type(__VA_ARGS__),*meta_fake(meta_choose_type(meta_is_array_type(__VA_ARGS__),typeof(__VA_ARGS__),int*)),void)

// Evaluates to whether the argument's type is decayed (i.e. cannot decay further).
#define meta_is_decayed_type(...) _Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):1,default:0)

// Evaluates to the argument's type, decayed.
// Integer-like types are not promoted.
#define meta_decay_type(...) typeof(_Generic(typeof_unqual(__VA_ARGS__),unsigned char:meta_fake(__VA_ARGS__),unsigned short:meta_fake(__VA_ARGS__),signed char:meta_fake(__VA_ARGS__),short:meta_fake(__VA_ARGS__),char:meta_fake(__VA_ARGS__),bool:meta_fake(__VA_ARGS__),default:0?meta_fake(__VA_ARGS__):meta_fake(__VA_ARGS__)))

// Evaluates to whether the argument's type is an integer type.
#define meta_is_int_type(...) (meta_is_unsigned_type(__VA_ARGS__)||meta_is_signed_type(__VA_ARGS__))

// Evaluates to whether the argument's type is an unsigned integer type.
#define meta_is_unsigned_type(...) _Generic(typeof_unqual(__VA_ARGS__),unsigned char:1,unsigned short:1,unsigned int:1,unsigned long:1,unsigned long long:1,default:0)

// Evaluates to whether the argument's type is a signed integer type.
#define meta_is_signed_type(...) _Generic(typeof_unqual(__VA_ARGS__),signed char:1,short:1,int:1,long:1,long long:1,default:0)

// Evaluates to whether the argument's type is a floating-point type.
#define meta_is_float_type(...) _Generic(typeof_unqual(__VA_ARGS__),float:1,double:1,long double:1,default:0)

// Evaluates to whether the argument's type has a const qualifier.
#define meta_is_const(...) _Generic(typeof(__VA_ARGS__),typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:meta_fake(__VA_ARGS__)))const:1,default:0)

// Evaluates to whether the argument's type has a volatile qualifier.
#define meta_is_volatile(...) _Generic(typeof(__VA_ARGS__),typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:meta_fake(__VA_ARGS__)))volatile:1,default:0)

// Evaluates to whether the argument's type has const and volatile qualifiers.
#define meta_is_const_volatile(...) _Generic(typeof(__VA_ARGS__),typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:meta_fake(__VA_ARGS__)))const volatile:1,default:0)

// Evaluates to whether the argument's type has an _Atomic qualifier.
#define meta_is_atomic(...) _Generic(typeof(__VA_ARGS__),typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:_Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):meta_fake(__VA_ARGS__),default:0)))_Atomic:1,default:0)

// Evaluates to whether the argument's type has const and _Atomic qualifiers.
#define meta_is_const_atomic(...) _Generic(typeof(__VA_ARGS__),typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:_Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):meta_fake(__VA_ARGS__),default:0)))const _Atomic:1,default:0)

// Evaluates to whether the argument's type has volatile and _Atomic qualifiers.
#define meta_is_volatile_atomic(...) _Generic(typeof(__VA_ARGS__),typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:_Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):meta_fake(__VA_ARGS__),default:0)))volatile _Atomic:1,default:0)

// Evaluates to whether the argument's type has const, volatile, and _Atomic qualifiers.
#define meta_is_const_volatile_atomic(...) _Generic(typeof(__VA_ARGS__),typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:_Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):meta_fake(__VA_ARGS__),default:0)))const volatile _Atomic:1,default:0)

// Evaluates to whether the argument's type has a restrict qualifier.
#define meta_is_restrict(...) _Generic(typeof(__VA_ARGS__),meta_choose_type(meta_is_atomic(__VA_ARGS__),meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const_volatile_atomic(typeof_unqual(__VA_ARGS__)),meta_add_volatile_atomic(typeof_unqual(__VA_ARGS__))),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const_atomic(typeof_unqual(__VA_ARGS__)),meta_add_atomic(typeof_unqual(__VA_ARGS__)))),meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const_volatile(typeof_unqual(__VA_ARGS__)),meta_add_volatile(typeof_unqual(__VA_ARGS__))),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__)))):0,default:1)

// Evaluates to whether the argument's type has const and restrict qualifiers.
#define meta_is_const_restrict(...) (meta_is_const(__VA_ARGS__)&&meta_is_restrict(__VA_ARGS__))

// Evaluates to whether the argument's type has volatile and restrict qualifiers.
#define meta_is_volatile_restrict(...) (meta_is_volatile(__VA_ARGS__)&&meta_is_restrict(__VA_ARGS__))

// Evaluates to whether the argument's type has const, volatile, and restrict qualifiers.
#define meta_is_const_volatile_restrict(...) (meta_is_const_volatile(__VA_ARGS__)&&meta_is_restrict(__VA_ARGS__))

// Evaluates to whether the argument's type has _Atomic and restrict qualifiers.
#define meta_is_atomic_restrict(...) (meta_is_atomic(__VA_ARGS__)&&meta_is_restrict(__VA_ARGS__))

// Evaluates to whether the argument's type has const, _Atomic, and restrict qualifiers.
#define meta_is_const_atomic_restrict(...) (meta_is_const_atomic(__VA_ARGS__)&&meta_is_restrict(__VA_ARGS__))

// Evaluates to whether the argument's type has volatile, _Atomic, and restrict qualifiers.
#define meta_is_volatile_atomic_restrict(...) (meta_is_volatile_atomic(__VA_ARGS__)&&meta_is_restrict(__VA_ARGS__))

// Evaluates to whether the argument's type has const, volatile, _Atomic, and restrict qualifiers.
#define meta_is_const_volatile_atomic_restrict(...) (meta_is_const_volatile_atomic(__VA_ARGS__)&&meta_is_restrict(__VA_ARGS__))

// Evaluates to the argument's type with a const qualifier.
// If the argument's type is a function type, it is unchanged.
#define meta_add_const(...) typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:meta_fake(__VA_ARGS__),default:meta_fake(typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:meta_fake(__VA_ARGS__)))const)))

// Evaluates to the argument's type with a volatile qualifier.
// If the argument's type is a function type, it is unchanged.
#define meta_add_volatile(...) typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:meta_fake(__VA_ARGS__),default:meta_fake(typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:meta_fake(__VA_ARGS__)))volatile)))

// Evaluates to the argument's type with const and volatile qualifiers.
// If the argument's type is a function type, it is unchanged.
#define meta_add_const_volatile(...) typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:meta_fake(__VA_ARGS__),default:meta_fake(typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:meta_fake(__VA_ARGS__)))const volatile)))

// Evaluates to the argument's type with an _Atomic qualifier.
// If the argument's type is a function or array type, it is unchanged.
#define meta_add_atomic(...) typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:meta_fake(__VA_ARGS__),default:_Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:meta_fake(typeof(_Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):meta_fake(__VA_ARGS__),default:0))_Atomic)),default:meta_fake(__VA_ARGS__))))

// Evaluates to the argument's type with const and _Atomic qualifiers.
// If the argument's type is a function or array type, it is unchanged.
#define meta_add_const_atomic(...) typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:meta_fake(__VA_ARGS__),default:_Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:meta_fake(typeof(_Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):meta_fake(__VA_ARGS__),default:0))const _Atomic)),default:meta_fake(__VA_ARGS__))))

// Evaluates to the argument's type with volatile and _Atomic qualifiers.
// If the argument's type is a function or array type, it is unchanged.
#define meta_add_volatile_atomic(...) typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:meta_fake(__VA_ARGS__),default:_Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:meta_fake(typeof(_Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):meta_fake(__VA_ARGS__),default:0))volatile _Atomic)),default:meta_fake(__VA_ARGS__))))

// Evaluates to the argument's type with const, volatile, and _Atomic qualifiers.
// If the argument's type is a function or array type, it is unchanged.
#define meta_add_const_volatile_atomic(...) typeof(_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:meta_fake(__VA_ARGS__),default:_Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):_Generic(meta_fake(__VA_ARGS__),typeof(__VA_ARGS__)*:0,default:meta_fake(typeof(_Generic(typeof_unqual(__VA_ARGS__),typeof_unqual(meta_decay_type(__VA_ARGS__)):meta_fake(__VA_ARGS__),default:0))const volatile _Atomic)),default:meta_fake(__VA_ARGS__))))

// Evaluates to the argument's type without a const qualifier.
#define meta_drop_const(...) meta_choose_type(meta_is_restrict(__VA_ARGS__),meta_choose_type(meta_is_restrict(__VA_ARGS__),meta_choose_type(meta_is_atomic(__VA_ARGS__),meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_add_volatile_atomic(typeof_unqual(__VA_ARGS__)),meta_add_atomic(typeof_unqual(__VA_ARGS__))),meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_add_volatile(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__))),int*)restrict,meta_choose_type(meta_is_atomic(__VA_ARGS__),meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_add_volatile_atomic(typeof_unqual(__VA_ARGS__)),meta_add_atomic(typeof_unqual(__VA_ARGS__))),meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_add_volatile(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__))))

// Evaluates to the argument's type without a volatile qualifier.
#define meta_drop_volatile(...) meta_choose_type(meta_is_restrict(__VA_ARGS__),meta_choose_type(meta_is_restrict(__VA_ARGS__),meta_choose_type(meta_is_atomic(__VA_ARGS__),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const_atomic(typeof_unqual(__VA_ARGS__)),meta_add_atomic(typeof_unqual(__VA_ARGS__))),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__))),int*)restrict,meta_choose_type(meta_is_atomic(__VA_ARGS__),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const_atomic(typeof_unqual(__VA_ARGS__)),meta_add_atomic(typeof_unqual(__VA_ARGS__))),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__))))

// Evaluates to the argument's type without const and volatile qualifiers.
#define meta_drop_const_volatile(...) meta_choose_type(meta_is_restrict(__VA_ARGS__),meta_choose_type(meta_is_restrict(__VA_ARGS__),meta_choose_type(meta_is_atomic(__VA_ARGS__),meta_add_atomic(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__)),int*)restrict,meta_choose_type(meta_is_atomic(__VA_ARGS__),meta_add_atomic(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__)))

// Evaluates to the argument's type without an _Atomic qualifier.
#define meta_drop_atomic(...) meta_choose_type(meta_is_restrict(__VA_ARGS__),meta_choose_type(meta_is_restrict(__VA_ARGS__),meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const_volatile(typeof_unqual(__VA_ARGS__)),meta_add_volatile(typeof_unqual(__VA_ARGS__))),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__))),int*)restrict,meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const_volatile(typeof_unqual(__VA_ARGS__)),meta_add_volatile(typeof_unqual(__VA_ARGS__))),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__))))

// Evaluates to the argument's type without const and _Atomic qualifiers.
#define meta_drop_const_atomic(...) meta_choose_type(meta_is_restrict(__VA_ARGS__),meta_choose_type(meta_is_restrict(__VA_ARGS__),meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_add_volatile(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__)),int*)restrict,meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_add_volatile(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__)))

// Evaluates to the argument's type without volatile and _Atomic qualifiers.
#define meta_drop_volatile_atomic(...) meta_choose_type(meta_is_restrict(__VA_ARGS__),meta_choose_type(meta_is_restrict(__VA_ARGS__),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__)),int*)restrict,meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__)))

// Evaluates to the argument's type without const, volatile, and _Atomic qualifiers.
#define meta_drop_const_volatile_atomic(...) meta_choose_type(meta_is_restrict(__VA_ARGS__),meta_choose_type(meta_is_restrict(__VA_ARGS__),typeof_unqual(__VA_ARGS__),int*)restrict,typeof_unqual(__VA_ARGS__))

// Evaluates to the argument's type without a restrict qualifier.
#define meta_drop_restrict(...) meta_choose_type(meta_is_atomic(__VA_ARGS__),meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const_volatile_atomic(typeof_unqual(__VA_ARGS__)),meta_add_volatile_atomic(typeof_unqual(__VA_ARGS__))),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const_atomic(typeof_unqual(__VA_ARGS__)),meta_add_atomic(typeof_unqual(__VA_ARGS__)))),meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const_volatile(typeof_unqual(__VA_ARGS__)),meta_add_volatile(typeof_unqual(__VA_ARGS__))),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__))))

// Evaluates to the argument's type without const and restrict qualifiers.
#define meta_drop_const_restrict(...) meta_choose_type(meta_is_atomic(__VA_ARGS__),meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_add_volatile_atomic(typeof_unqual(__VA_ARGS__)),meta_add_atomic(typeof_unqual(__VA_ARGS__))),meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_add_volatile(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__)))

// Evaluates to the argument's type without volatile and restrict qualifiers.
#define meta_drop_volatile_restrict(...) meta_choose_type(meta_is_atomic(__VA_ARGS__),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const_atomic(typeof_unqual(__VA_ARGS__)),meta_add_atomic(typeof_unqual(__VA_ARGS__))),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__)))

// Evaluates to the argument's type without const, volatile, and restrict qualifiers.
#define meta_drop_const_volatile_restrict(...) meta_choose_type(meta_is_atomic(__VA_ARGS__),meta_add_atomic(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__))

// Evaluates to the argument's type without _Atomic and restrict qualifiers.
#define meta_drop_atomic_restrict(...) meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const_volatile(typeof_unqual(__VA_ARGS__)),meta_add_volatile(typeof_unqual(__VA_ARGS__))),meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__)))

// Evaluates to the argument's type without const, _Atomic, and restrict qualifiers.
#define meta_drop_const_atomic_restrict(...) meta_choose_type(meta_is_volatile(__VA_ARGS__),meta_add_volatile(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__))

// Evaluates to the argument's type without volatile, _Atomic, and restrict qualifiers.
#define meta_drop_volatile_atomic_restrict(...) meta_choose_type(meta_is_const(__VA_ARGS__),meta_add_const(typeof_unqual(__VA_ARGS__)),typeof_unqual(__VA_ARGS__))

// Evaluates to the argument's type without const, volatile, _Atomic, and restrict qualifiers.
#define meta_drop_const_volatile_atomic_restrict(...) typeof_unqual(__VA_ARGS__)

// Evaluates to whether an identifier represents a type.
#define meta_is_type_name(NAME) (!meta_is_same_type(int(int(NAME)),int(int)))

test.c

static_assert(meta_is_same_type(int, int));
static_assert(!meta_is_same_type(int, char));
static_assert(!meta_is_same_type(int, const int));
static_assert(!meta_is_same_type(int, int*));
static_assert(meta_is_same_type(int*, int*));
static_assert(!meta_is_same_type(int*, const int*));
static_assert(!meta_is_same_type(int*, int* const));
static_assert(meta_is_same_type(int(int), int(int)));
static_assert(meta_is_same_type(int(int), int(const int)));
static_assert(!meta_is_same_type(int(int), int(char)));
static_assert(!meta_is_same_type(int(int), int));
static_assert(!meta_is_same_type(int(int), int(*)(int)));
static_assert(meta_is_same_type(int[], int[]));
static_assert(!meta_is_same_type(int[], int));
static_assert(meta_is_same_type(int[3], int[3]));
static_assert(!meta_is_same_type(int[3], int));
static_assert(!meta_is_same_type(int[3], int*));
static_assert(!meta_is_same_type(int[3], int[]));
static_assert(meta_is_same_type(42, int));
static_assert(meta_is_same_type("Hello", char[6]));

static_assert(meta_is_same_type_unqual(int, const volatile _Atomic int));
static_assert(meta_is_same_type_unqual(int[], const int[]));
static_assert(!meta_is_same_type_unqual(int(int*), int(const int*)));

static_assert(meta_choose_expr(true, 1, 2) == 1);
static_assert(meta_choose_expr(false, 1, 2) == 2);

static_assert(meta_is_same_type(meta_choose_type(true, int, char), int));
static_assert(meta_is_same_type(meta_choose_type(false, int, char), char));

static_assert(meta_is_same_type(typeof(meta_fake(int) + 1), int));
static_assert(meta_is_same_type(typeof(meta_fake(*meta_fake(const int*))), const int));

static_assert(meta_is_same_type(typeof(meta_fake_unqual(*meta_fake(const int*))), int));

static_assert(!meta_is_function_type(int));
static_assert(meta_is_function_type(int(int)));
static_assert(!meta_is_function_type(int(*)(int)));

static_assert(!meta_is_array_type(int));
static_assert(!meta_is_array_type(int*));
static_assert(meta_is_array_type(int[]));
static_assert(meta_is_array_type(int[3]));
static_assert(!meta_is_array_type(int(int)));

static_assert(!meta_is_bounded_array_type(int));
static_assert(meta_is_bounded_array_type(int[3]));
static_assert(!meta_is_bounded_array_type(int[]));
static_assert(!meta_is_bounded_array_type(int(int)));

static_assert(!meta_is_unbounded_array_type(int));
static_assert(!meta_is_unbounded_array_type(int[3]));
static_assert(meta_is_unbounded_array_type(int[]));
static_assert(!meta_is_unbounded_array_type(int(int)));

static_assert(meta_array_extent(int[3]) == 3);
static_assert(meta_array_extent(int[]) == 0);

static_assert(meta_is_same_type(meta_array_value_type(int[]), int));
static_assert(meta_is_same_type(meta_array_value_type(int[3]), int));
static_assert(meta_is_same_type(meta_array_value_type("Hello"), char));
static_assert(meta_is_same_type(meta_array_value_type(const volatile int[]), const volatile int));
static_assert(meta_is_same_type(meta_array_value_type(int), void));

static_assert(meta_is_decayed_type(int));
static_assert(meta_is_decayed_type(int*));
static_assert(meta_is_decayed_type(int(*)(int)));
static_assert(!meta_is_decayed_type(int[]));
static_assert(!meta_is_decayed_type(int[3]));
static_assert(!meta_is_decayed_type(int(int)));

static_assert(meta_is_same_type(meta_decay_type(int), int));
static_assert(meta_is_same_type(meta_decay_type(char), char));
static_assert(meta_is_same_type(meta_decay_type(int[]), int*));
static_assert(meta_is_same_type(meta_decay_type(int[3]), int*));
static_assert(meta_is_same_type(meta_decay_type(int(int)), int(*)(int)));

static_assert(meta_is_int_type(int));
static_assert(meta_is_int_type(const int));
static_assert(!meta_is_int_type(int*));
static_assert(!meta_is_int_type(int[]));
static_assert(!meta_is_int_type(int(int)));

static_assert(meta_is_unsigned_type(unsigned char));
static_assert(meta_is_unsigned_type(unsigned short));
static_assert(meta_is_unsigned_type(unsigned int));
static_assert(meta_is_unsigned_type(unsigned long));
static_assert(meta_is_unsigned_type(unsigned long long));
static_assert(!meta_is_unsigned_type(char));
static_assert(!meta_is_unsigned_type(char));
static_assert(!meta_is_unsigned_type(short));
static_assert(!meta_is_unsigned_type(int));
static_assert(!meta_is_unsigned_type(long));
static_assert(!meta_is_unsigned_type(long long));

static_assert(meta_is_signed_type(signed char));
static_assert(meta_is_signed_type(short));
static_assert(meta_is_signed_type(int));
static_assert(meta_is_signed_type(long));
static_assert(meta_is_signed_type(long long));
static_assert(!meta_is_signed_type(char));
static_assert(!meta_is_signed_type(unsigned char));
static_assert(!meta_is_signed_type(unsigned short));
static_assert(!meta_is_signed_type(unsigned int));
static_assert(!meta_is_signed_type(unsigned long));
static_assert(!meta_is_signed_type(unsigned long long));

static_assert(!meta_is_float_type(int));
static_assert(meta_is_float_type(float));
static_assert(meta_is_float_type(double));
static_assert(meta_is_float_type(long double));

static_assert(!meta_is_const(int));
static_assert(meta_is_const(const int));
static_assert(!meta_is_const(volatile int));
static_assert(meta_is_const(const volatile int));
static_assert(!meta_is_const(_Atomic int));
static_assert(meta_is_const(const _Atomic int));
static_assert(!meta_is_const(volatile _Atomic int));
static_assert(meta_is_const(const volatile _Atomic int));
static_assert(!meta_is_const(int* restrict));
static_assert(meta_is_const(int* const restrict));
static_assert(!meta_is_const(int* volatile restrict));
static_assert(meta_is_const(int* const volatile restrict));
static_assert(!meta_is_const(int* _Atomic restrict));
static_assert(meta_is_const(int* const _Atomic restrict));
static_assert(!meta_is_const(int* volatile _Atomic restrict));
static_assert(meta_is_const(int* const volatile _Atomic restrict));
static_assert(!meta_is_const(int(int)));

static_assert(!meta_is_volatile(int));
static_assert(!meta_is_volatile(const int));
static_assert(meta_is_volatile(volatile int));
static_assert(meta_is_volatile(const volatile int));
static_assert(!meta_is_volatile(_Atomic int));
static_assert(!meta_is_volatile(const _Atomic int));
static_assert(meta_is_volatile(volatile _Atomic int));
static_assert(meta_is_volatile(const volatile _Atomic int));
static_assert(!meta_is_volatile(int* restrict));
static_assert(!meta_is_volatile(int* const restrict));
static_assert(meta_is_volatile(int* volatile restrict));
static_assert(meta_is_volatile(int* const volatile restrict));
static_assert(!meta_is_volatile(int* _Atomic restrict));
static_assert(!meta_is_volatile(int* const _Atomic restrict));
static_assert(meta_is_volatile(int* volatile _Atomic restrict));
static_assert(meta_is_volatile(int* const volatile _Atomic restrict));

static_assert(!meta_is_const_volatile(int));
static_assert(!meta_is_const_volatile(const int));
static_assert(!meta_is_const_volatile(volatile int));
static_assert(meta_is_const_volatile(const volatile int));
static_assert(!meta_is_const_volatile(_Atomic int));
static_assert(!meta_is_const_volatile(const _Atomic int));
static_assert(!meta_is_const_volatile(volatile _Atomic int));
static_assert(meta_is_const_volatile(const volatile _Atomic int));
static_assert(!meta_is_const_volatile(int* restrict));
static_assert(!meta_is_const_volatile(int* const restrict));
static_assert(!meta_is_const_volatile(int* volatile restrict));
static_assert(meta_is_const_volatile(int* const volatile restrict));
static_assert(!meta_is_const_volatile(int* _Atomic restrict));
static_assert(!meta_is_const_volatile(int* const _Atomic restrict));
static_assert(!meta_is_const_volatile(int* volatile _Atomic restrict));
static_assert(meta_is_const_volatile(int* const volatile _Atomic restrict));

static_assert(!meta_is_atomic(int));
static_assert(!meta_is_atomic(const int));
static_assert(!meta_is_atomic(volatile int));
static_assert(!meta_is_atomic(const volatile int));
static_assert(meta_is_atomic(_Atomic int));
static_assert(meta_is_atomic(const _Atomic int));
static_assert(meta_is_atomic(volatile _Atomic int));
static_assert(meta_is_atomic(const volatile _Atomic int));
static_assert(!meta_is_atomic(int* restrict));
static_assert(!meta_is_atomic(int* const restrict));
static_assert(!meta_is_atomic(int* volatile restrict));
static_assert(!meta_is_atomic(int* const volatile restrict));
static_assert(meta_is_atomic(int* _Atomic restrict));
static_assert(meta_is_atomic(int* const _Atomic restrict));
static_assert(meta_is_atomic(int* volatile _Atomic restrict));
static_assert(meta_is_atomic(int* const volatile _Atomic restrict));
static_assert(!meta_is_atomic(int[]));
static_assert(!meta_is_atomic(int(int)));

static_assert(!meta_is_const_atomic(int));
static_assert(!meta_is_const_atomic(const int));
static_assert(!meta_is_const_atomic(volatile int));
static_assert(!meta_is_const_atomic(const volatile int));
static_assert(!meta_is_const_atomic(_Atomic int));
static_assert(meta_is_const_atomic(const _Atomic int));
static_assert(!meta_is_const_atomic(volatile _Atomic int));
static_assert(meta_is_const_atomic(const volatile _Atomic int));
static_assert(!meta_is_const_atomic(int* restrict));
static_assert(!meta_is_const_atomic(int* const restrict));
static_assert(!meta_is_const_atomic(int* volatile restrict));
static_assert(!meta_is_const_atomic(int* const volatile restrict));
static_assert(!meta_is_const_atomic(int* _Atomic restrict));
static_assert(meta_is_const_atomic(int* const _Atomic restrict));
static_assert(!meta_is_const_atomic(int* volatile _Atomic restrict));
static_assert(meta_is_const_atomic(int* const volatile _Atomic restrict));

static_assert(!meta_is_volatile_atomic(int));
static_assert(!meta_is_volatile_atomic(const int));
static_assert(!meta_is_volatile_atomic(volatile int));
static_assert(!meta_is_volatile_atomic(const volatile int));
static_assert(!meta_is_volatile_atomic(_Atomic int));
static_assert(!meta_is_volatile_atomic(const _Atomic int));
static_assert(meta_is_volatile_atomic(volatile _Atomic int));
static_assert(meta_is_volatile_atomic(const volatile _Atomic int));
static_assert(!meta_is_volatile_atomic(int* restrict));
static_assert(!meta_is_volatile_atomic(int* const restrict));
static_assert(!meta_is_volatile_atomic(int* volatile restrict));
static_assert(!meta_is_volatile_atomic(int* const volatile restrict));
static_assert(!meta_is_volatile_atomic(int* _Atomic restrict));
static_assert(!meta_is_volatile_atomic(int* const _Atomic restrict));
static_assert(meta_is_volatile_atomic(int* volatile _Atomic restrict));
static_assert(meta_is_volatile_atomic(int* const volatile _Atomic restrict));

static_assert(!meta_is_const_volatile_atomic(int));
static_assert(!meta_is_const_volatile_atomic(const int));
static_assert(!meta_is_const_volatile_atomic(volatile int));
static_assert(!meta_is_const_volatile_atomic(const volatile int));
static_assert(!meta_is_const_volatile_atomic(_Atomic int));
static_assert(!meta_is_const_volatile_atomic(const _Atomic int));
static_assert(!meta_is_const_volatile_atomic(volatile _Atomic int));
static_assert(meta_is_const_volatile_atomic(const volatile _Atomic int));
static_assert(!meta_is_const_volatile_atomic(int* restrict));
static_assert(!meta_is_const_volatile_atomic(int* const restrict));
static_assert(!meta_is_const_volatile_atomic(int* volatile restrict));
static_assert(!meta_is_const_volatile_atomic(int* const volatile restrict));
static_assert(!meta_is_const_volatile_atomic(int* _Atomic restrict));
static_assert(!meta_is_const_volatile_atomic(int* const _Atomic restrict));
static_assert(!meta_is_const_volatile_atomic(int* volatile _Atomic restrict));
static_assert(meta_is_const_volatile_atomic(int* const volatile _Atomic restrict));

static_assert(!meta_is_restrict(int));
static_assert(!meta_is_restrict(const int));
static_assert(!meta_is_restrict(volatile int));
static_assert(!meta_is_restrict(const volatile int));
static_assert(!meta_is_restrict(_Atomic int));
static_assert(!meta_is_restrict(const _Atomic int));
static_assert(!meta_is_restrict(volatile _Atomic int));
static_assert(!meta_is_restrict(const volatile _Atomic int));
static_assert(meta_is_restrict(int* restrict));
static_assert(meta_is_restrict(int* const restrict));
static_assert(meta_is_restrict(int* volatile restrict));
static_assert(meta_is_restrict(int* const volatile restrict));
static_assert(meta_is_restrict(int* _Atomic restrict));
static_assert(meta_is_restrict(int* const _Atomic restrict));
static_assert(meta_is_restrict(int* volatile _Atomic restrict));
static_assert(meta_is_restrict(int* const volatile _Atomic restrict));

static_assert(!meta_is_const_restrict(int));
static_assert(!meta_is_const_restrict(const int));
static_assert(!meta_is_const_restrict(volatile int));
static_assert(!meta_is_const_restrict(const volatile int));
static_assert(!meta_is_const_restrict(_Atomic int));
static_assert(!meta_is_const_restrict(const _Atomic int));
static_assert(!meta_is_const_restrict(volatile _Atomic int));
static_assert(!meta_is_const_restrict(const volatile _Atomic int));
static_assert(!meta_is_const_restrict(int* restrict));
static_assert(meta_is_const_restrict(int* const restrict));
static_assert(!meta_is_const_restrict(int* volatile restrict));
static_assert(meta_is_const_restrict(int* const volatile restrict));
static_assert(!meta_is_const_restrict(int* _Atomic restrict));
static_assert(meta_is_const_restrict(int* const _Atomic restrict));
static_assert(!meta_is_const_restrict(int* volatile _Atomic restrict));
static_assert(meta_is_const_restrict(int* const volatile _Atomic restrict));

static_assert(!meta_is_volatile_restrict(int));
static_assert(!meta_is_volatile_restrict(const int));
static_assert(!meta_is_volatile_restrict(volatile int));
static_assert(!meta_is_volatile_restrict(const volatile int));
static_assert(!meta_is_volatile_restrict(_Atomic int));
static_assert(!meta_is_volatile_restrict(const _Atomic int));
static_assert(!meta_is_volatile_restrict(volatile _Atomic int));
static_assert(!meta_is_volatile_restrict(const volatile _Atomic int));
static_assert(!meta_is_volatile_restrict(int* restrict));
static_assert(!meta_is_volatile_restrict(int* const restrict));
static_assert(meta_is_volatile_restrict(int* volatile restrict));
static_assert(meta_is_volatile_restrict(int* const volatile restrict));
static_assert(!meta_is_volatile_restrict(int* _Atomic restrict));
static_assert(!meta_is_volatile_restrict(int* const _Atomic restrict));
static_assert(meta_is_volatile_restrict(int* volatile _Atomic restrict));
static_assert(meta_is_volatile_restrict(int* const volatile _Atomic restrict));

static_assert(!meta_is_const_volatile_restrict(int));
static_assert(!meta_is_const_volatile_restrict(const int));
static_assert(!meta_is_const_volatile_restrict(volatile int));
static_assert(!meta_is_const_volatile_restrict(const volatile int));
static_assert(!meta_is_const_volatile_restrict(_Atomic int));
static_assert(!meta_is_const_volatile_restrict(const _Atomic int));
static_assert(!meta_is_const_volatile_restrict(volatile _Atomic int));
static_assert(!meta_is_const_volatile_restrict(const volatile _Atomic int));
static_assert(!meta_is_const_volatile_restrict(int* restrict));
static_assert(!meta_is_const_volatile_restrict(int* const restrict));
static_assert(!meta_is_const_volatile_restrict(int* volatile restrict));
static_assert(meta_is_const_volatile_restrict(int* const volatile restrict));
static_assert(!meta_is_const_volatile_restrict(int* _Atomic restrict));
static_assert(!meta_is_const_volatile_restrict(int* const _Atomic restrict));
static_assert(!meta_is_const_volatile_restrict(int* volatile _Atomic restrict));
static_assert(meta_is_const_volatile_restrict(int* const volatile _Atomic restrict));

static_assert(!meta_is_atomic_restrict(int));
static_assert(!meta_is_atomic_restrict(const int));
static_assert(!meta_is_atomic_restrict(volatile int));
static_assert(!meta_is_atomic_restrict(const volatile int));
static_assert(!meta_is_atomic_restrict(_Atomic int));
static_assert(!meta_is_atomic_restrict(const _Atomic int));
static_assert(!meta_is_atomic_restrict(volatile _Atomic int));
static_assert(!meta_is_atomic_restrict(const volatile _Atomic int));
static_assert(!meta_is_atomic_restrict(int* restrict));
static_assert(!meta_is_atomic_restrict(int* const restrict));
static_assert(!meta_is_atomic_restrict(int* volatile restrict));
static_assert(!meta_is_atomic_restrict(int* const volatile restrict));
static_assert(meta_is_atomic_restrict(int* _Atomic restrict));
static_assert(meta_is_atomic_restrict(int* const _Atomic restrict));
static_assert(meta_is_atomic_restrict(int* volatile _Atomic restrict));
static_assert(meta_is_atomic_restrict(int* const volatile _Atomic restrict));

static_assert(!meta_is_const_atomic_restrict(int));
static_assert(!meta_is_const_atomic_restrict(const int));
static_assert(!meta_is_const_atomic_restrict(volatile int));
static_assert(!meta_is_const_atomic_restrict(const volatile int));
static_assert(!meta_is_const_atomic_restrict(_Atomic int));
static_assert(!meta_is_const_atomic_restrict(const _Atomic int));
static_assert(!meta_is_const_atomic_restrict(volatile _Atomic int));
static_assert(!meta_is_const_atomic_restrict(const volatile _Atomic int));
static_assert(!meta_is_const_atomic_restrict(int* restrict));
static_assert(!meta_is_const_atomic_restrict(int* const restrict));
static_assert(!meta_is_const_atomic_restrict(int* volatile restrict));
static_assert(!meta_is_const_atomic_restrict(int* const volatile restrict));
static_assert(!meta_is_const_atomic_restrict(int* _Atomic restrict));
static_assert(meta_is_const_atomic_restrict(int* const _Atomic restrict));
static_assert(!meta_is_const_atomic_restrict(int* volatile _Atomic restrict));
static_assert(meta_is_const_atomic_restrict(int* const volatile _Atomic restrict));

static_assert(!meta_is_volatile_atomic_restrict(int));
static_assert(!meta_is_volatile_atomic_restrict(const int));
static_assert(!meta_is_volatile_atomic_restrict(volatile int));
static_assert(!meta_is_volatile_atomic_restrict(const volatile int));
static_assert(!meta_is_volatile_atomic_restrict(_Atomic int));
static_assert(!meta_is_volatile_atomic_restrict(const _Atomic int));
static_assert(!meta_is_volatile_atomic_restrict(volatile _Atomic int));
static_assert(!meta_is_volatile_atomic_restrict(const volatile _Atomic int));
static_assert(!meta_is_volatile_atomic_restrict(int* restrict));
static_assert(!meta_is_volatile_atomic_restrict(int* const restrict));
static_assert(!meta_is_volatile_atomic_restrict(int* volatile restrict));
static_assert(!meta_is_volatile_atomic_restrict(int* const volatile restrict));
static_assert(!meta_is_volatile_atomic_restrict(int* _Atomic restrict));
static_assert(!meta_is_volatile_atomic_restrict(int* const _Atomic restrict));
static_assert(meta_is_volatile_atomic_restrict(int* volatile _Atomic restrict));
static_assert(meta_is_volatile_atomic_restrict(int* const volatile _Atomic restrict));

static_assert(!meta_is_const_volatile_atomic_restrict(int));
static_assert(!meta_is_const_volatile_atomic_restrict(const int));
static_assert(!meta_is_const_volatile_atomic_restrict(volatile int));
static_assert(!meta_is_const_volatile_atomic_restrict(const volatile int));
static_assert(!meta_is_const_volatile_atomic_restrict(_Atomic int));
static_assert(!meta_is_const_volatile_atomic_restrict(const _Atomic int));
static_assert(!meta_is_const_volatile_atomic_restrict(volatile _Atomic int));
static_assert(!meta_is_const_volatile_atomic_restrict(const volatile _Atomic int));
static_assert(!meta_is_const_volatile_atomic_restrict(int* restrict));
static_assert(!meta_is_const_volatile_atomic_restrict(int* const restrict));
static_assert(!meta_is_const_volatile_atomic_restrict(int* volatile restrict));
static_assert(!meta_is_const_volatile_atomic_restrict(int* const volatile restrict));
static_assert(!meta_is_const_volatile_atomic_restrict(int* _Atomic restrict));
static_assert(!meta_is_const_volatile_atomic_restrict(int* const _Atomic restrict));
static_assert(!meta_is_const_volatile_atomic_restrict(int* volatile _Atomic restrict));
static_assert(meta_is_const_volatile_atomic_restrict(int* const volatile _Atomic restrict));

static_assert(meta_is_same_type(meta_add_const(int), const int));
static_assert(meta_is_same_type(meta_add_const(const int), const int));
static_assert(meta_is_same_type(meta_add_const(volatile int), const volatile int));
static_assert(meta_is_same_type(meta_add_const(const volatile int), const volatile int));
static_assert(meta_is_same_type(meta_add_const(_Atomic int), const _Atomic int));
static_assert(meta_is_same_type(meta_add_const(const _Atomic int), const _Atomic int));
static_assert(meta_is_same_type(meta_add_const(volatile _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const(const volatile _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const(int* restrict), int* const restrict));
static_assert(meta_is_same_type(meta_add_const(int* const restrict), int* const restrict));
static_assert(meta_is_same_type(meta_add_const(int* volatile restrict), int* const volatile restrict));
static_assert(meta_is_same_type(meta_add_const(int* const volatile restrict), int* const volatile restrict));
static_assert(meta_is_same_type(meta_add_const(int* _Atomic restrict), int* const _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const(int* const _Atomic restrict), int* const _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const(int* volatile _Atomic restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const(int* const volatile _Atomic restrict), int* const volatile _Atomic restrict));

static_assert(meta_is_same_type(meta_add_volatile(int), volatile int));
static_assert(meta_is_same_type(meta_add_volatile(const int), const volatile int));
static_assert(meta_is_same_type(meta_add_volatile(volatile int), volatile int));
static_assert(meta_is_same_type(meta_add_volatile(const volatile int), const volatile int));
static_assert(meta_is_same_type(meta_add_volatile(_Atomic int), volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_volatile(const _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_volatile(volatile _Atomic int), volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_volatile(const volatile _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_volatile(int* restrict), int* volatile restrict));
static_assert(meta_is_same_type(meta_add_volatile(int* const restrict), int* const volatile restrict));
static_assert(meta_is_same_type(meta_add_volatile(int* volatile restrict), int* volatile restrict));
static_assert(meta_is_same_type(meta_add_volatile(int* const volatile restrict), int* const volatile restrict));
static_assert(meta_is_same_type(meta_add_volatile(int* _Atomic restrict), int* volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_volatile(int* const _Atomic restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_volatile(int* volatile _Atomic restrict), int* volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_volatile(int* const volatile _Atomic restrict), int* const volatile _Atomic restrict));

static_assert(meta_is_same_type(meta_add_const_volatile(int), const volatile int));
static_assert(meta_is_same_type(meta_add_const_volatile(const int), const volatile int));
static_assert(meta_is_same_type(meta_add_const_volatile(volatile int), const volatile int));
static_assert(meta_is_same_type(meta_add_const_volatile(const volatile int), const volatile int));
static_assert(meta_is_same_type(meta_add_const_volatile(_Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_volatile(const _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_volatile(volatile _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_volatile(const volatile _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_volatile(int* restrict), int* const volatile restrict));
static_assert(meta_is_same_type(meta_add_const_volatile(int* const restrict), int* const volatile restrict));
static_assert(meta_is_same_type(meta_add_const_volatile(int* volatile restrict), int* const volatile restrict));
static_assert(meta_is_same_type(meta_add_const_volatile(int* const volatile restrict), int* const volatile restrict));
static_assert(meta_is_same_type(meta_add_const_volatile(int* _Atomic restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_volatile(int* const _Atomic restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_volatile(int* volatile _Atomic restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_volatile(int* const volatile _Atomic restrict), int* const volatile _Atomic restrict));

static_assert(meta_is_same_type(meta_add_atomic(int), _Atomic int));
static_assert(meta_is_same_type(meta_add_atomic(const int), const _Atomic int));
static_assert(meta_is_same_type(meta_add_atomic(volatile int), volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_atomic(const volatile int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_atomic(_Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_add_atomic(const _Atomic int), const _Atomic int));
static_assert(meta_is_same_type(meta_add_atomic(volatile _Atomic int), volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_atomic(const volatile _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_atomic(int* restrict), int* _Atomic restrict));
static_assert(meta_is_same_type(meta_add_atomic(int* const restrict), int* const _Atomic restrict));
static_assert(meta_is_same_type(meta_add_atomic(int* volatile restrict), int* volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_atomic(int* const volatile restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_atomic(int* _Atomic restrict), int* _Atomic restrict));
static_assert(meta_is_same_type(meta_add_atomic(int* const _Atomic restrict), int* const _Atomic restrict));
static_assert(meta_is_same_type(meta_add_atomic(int* volatile _Atomic restrict), int* volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_atomic(int* const volatile _Atomic restrict), int* const volatile _Atomic restrict));

static_assert(meta_is_same_type(meta_add_const_atomic(int), const _Atomic int));
static_assert(meta_is_same_type(meta_add_const_atomic(const int), const _Atomic int));
static_assert(meta_is_same_type(meta_add_const_atomic(volatile int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_atomic(const volatile int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_atomic(_Atomic int), const _Atomic int));
static_assert(meta_is_same_type(meta_add_const_atomic(const _Atomic int), const _Atomic int));
static_assert(meta_is_same_type(meta_add_const_atomic(volatile _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_atomic(const volatile _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_atomic(int* restrict), int* const _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_atomic(int* const restrict), int* const _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_atomic(int* volatile restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_atomic(int* const volatile restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_atomic(int* _Atomic restrict), int* const _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_atomic(int* const _Atomic restrict), int* const _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_atomic(int* volatile _Atomic restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_atomic(int* const volatile _Atomic restrict), int* const volatile _Atomic restrict));

static_assert(meta_is_same_type(meta_add_volatile_atomic(int), volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_volatile_atomic(const int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_volatile_atomic(volatile int), volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_volatile_atomic(const volatile int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_volatile_atomic(_Atomic int), volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_volatile_atomic(const _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_volatile_atomic(volatile _Atomic int), volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_volatile_atomic(const volatile _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_volatile_atomic(int* restrict), int* volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_volatile_atomic(int* const restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_volatile_atomic(int* volatile restrict), int* volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_volatile_atomic(int* const volatile restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_volatile_atomic(int* _Atomic restrict), int* volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_volatile_atomic(int* const _Atomic restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_volatile_atomic(int* volatile _Atomic restrict), int* volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_volatile_atomic(int* const volatile _Atomic restrict), int* const volatile _Atomic restrict));

static_assert(meta_is_same_type(meta_add_const_volatile_atomic(int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_volatile_atomic(const int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_volatile_atomic(volatile int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_volatile_atomic(const volatile int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_volatile_atomic(_Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_volatile_atomic(const _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_volatile_atomic(volatile _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_volatile_atomic(const volatile _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_add_const_volatile_atomic(int* restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_volatile_atomic(int* const restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_volatile_atomic(int* volatile restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_volatile_atomic(int* const volatile restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_volatile_atomic(int* _Atomic restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_volatile_atomic(int* const _Atomic restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_volatile_atomic(int* volatile _Atomic restrict), int* const volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_add_const_volatile_atomic(int* const volatile _Atomic restrict), int* const volatile _Atomic restrict));

static_assert(meta_is_same_type(meta_drop_const(int), int));
static_assert(meta_is_same_type(meta_drop_const(const int), int));
static_assert(meta_is_same_type(meta_drop_const(volatile int), volatile int));
static_assert(meta_is_same_type(meta_drop_const(const volatile int), volatile int));
static_assert(meta_is_same_type(meta_drop_const(_Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_const(const _Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_const(volatile _Atomic int), volatile _Atomic int));
static_assert(meta_is_same_type(meta_drop_const(const volatile _Atomic int), volatile _Atomic int));
static_assert(meta_is_same_type(meta_drop_const(int* restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const(int* const restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const(int* volatile restrict), int* volatile restrict));
static_assert(meta_is_same_type(meta_drop_const(int* const volatile restrict), int* volatile restrict));
static_assert(meta_is_same_type(meta_drop_const(int* _Atomic restrict), int* _Atomic restrict));
static_assert(meta_is_same_type(meta_drop_const(int* const _Atomic restrict), int* _Atomic restrict));
static_assert(meta_is_same_type(meta_drop_const(int* volatile _Atomic restrict), int* volatile _Atomic restrict));
static_assert(meta_is_same_type(meta_drop_const(int* const volatile _Atomic restrict), int* volatile _Atomic restrict));

static_assert(meta_is_same_type(meta_drop_volatile(int), int));
static_assert(meta_is_same_type(meta_drop_volatile(const int), const int));
static_assert(meta_is_same_type(meta_drop_volatile(volatile int), int));
static_assert(meta_is_same_type(meta_drop_volatile(const volatile int), const int));
static_assert(meta_is_same_type(meta_drop_volatile(_Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_volatile(const _Atomic int), const _Atomic int));
static_assert(meta_is_same_type(meta_drop_volatile(volatile _Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_volatile(const volatile _Atomic int), const _Atomic int));
static_assert(meta_is_same_type(meta_drop_volatile(int* restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_volatile(int* const restrict), int* const restrict));
static_assert(meta_is_same_type(meta_drop_volatile(int* volatile restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_volatile(int* const volatile restrict), int* const restrict));
static_assert(meta_is_same_type(meta_drop_volatile(int* _Atomic restrict), int* _Atomic restrict));
static_assert(meta_is_same_type(meta_drop_volatile(int* const _Atomic restrict), int* const _Atomic restrict));
static_assert(meta_is_same_type(meta_drop_volatile(int* volatile _Atomic restrict), int* _Atomic restrict));
static_assert(meta_is_same_type(meta_drop_volatile(int* const volatile _Atomic restrict), int* const _Atomic restrict));

static_assert(meta_is_same_type(meta_drop_const_volatile(int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile(const int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile(volatile int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile(const volatile int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile(_Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_const_volatile(const _Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_const_volatile(volatile _Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_const_volatile(const volatile _Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_const_volatile(int* restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const_volatile(int* const restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const_volatile(int* volatile restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const_volatile(int* const volatile restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const_volatile(int* _Atomic restrict), int* _Atomic restrict));
static_assert(meta_is_same_type(meta_drop_const_volatile(int* const _Atomic restrict), int* _Atomic restrict));
static_assert(meta_is_same_type(meta_drop_const_volatile(int* volatile _Atomic restrict), int* _Atomic restrict));
static_assert(meta_is_same_type(meta_drop_const_volatile(int* const volatile _Atomic restrict), int* _Atomic restrict));

static_assert(meta_is_same_type(meta_drop_atomic(int), int));
static_assert(meta_is_same_type(meta_drop_atomic(const int), const int));
static_assert(meta_is_same_type(meta_drop_atomic(volatile int), volatile int));
static_assert(meta_is_same_type(meta_drop_atomic(const volatile int), const volatile int));
static_assert(meta_is_same_type(meta_drop_atomic(_Atomic int), int));
static_assert(meta_is_same_type(meta_drop_atomic(const _Atomic int), const int));
static_assert(meta_is_same_type(meta_drop_atomic(volatile _Atomic int), volatile int));
static_assert(meta_is_same_type(meta_drop_atomic(const volatile _Atomic int), const volatile int));
static_assert(meta_is_same_type(meta_drop_atomic(int* restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_atomic(int* const restrict), int* const restrict));
static_assert(meta_is_same_type(meta_drop_atomic(int* volatile restrict), int* volatile restrict));
static_assert(meta_is_same_type(meta_drop_atomic(int* const volatile restrict), int* const volatile restrict));
static_assert(meta_is_same_type(meta_drop_atomic(int* _Atomic restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_atomic(int* const _Atomic restrict), int* const restrict));
static_assert(meta_is_same_type(meta_drop_atomic(int* volatile _Atomic restrict), int* volatile restrict));
static_assert(meta_is_same_type(meta_drop_atomic(int* const volatile _Atomic restrict), int* const volatile restrict));

static_assert(meta_is_same_type(meta_drop_const_atomic(int), int));
static_assert(meta_is_same_type(meta_drop_const_atomic(const int), int));
static_assert(meta_is_same_type(meta_drop_const_atomic(volatile int), volatile int));
static_assert(meta_is_same_type(meta_drop_const_atomic(const volatile int), volatile int));
static_assert(meta_is_same_type(meta_drop_const_atomic(_Atomic int), int));
static_assert(meta_is_same_type(meta_drop_const_atomic(const _Atomic int), int));
static_assert(meta_is_same_type(meta_drop_const_atomic(volatile _Atomic int), volatile int));
static_assert(meta_is_same_type(meta_drop_const_atomic(const volatile _Atomic int), volatile int));
static_assert(meta_is_same_type(meta_drop_const_atomic(int* restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const_atomic(int* const restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const_atomic(int* volatile restrict), int* volatile restrict));
static_assert(meta_is_same_type(meta_drop_const_atomic(int* const volatile restrict), int* volatile restrict));
static_assert(meta_is_same_type(meta_drop_const_atomic(int* _Atomic restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const_atomic(int* const _Atomic restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const_atomic(int* volatile _Atomic restrict), int* volatile restrict));
static_assert(meta_is_same_type(meta_drop_const_atomic(int* const volatile _Atomic restrict), int* volatile restrict));

static_assert(meta_is_same_type(meta_drop_volatile_atomic(int), int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic(const int), const int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic(volatile int), int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic(const volatile int), const int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic(_Atomic int), int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic(const _Atomic int), const int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic(volatile _Atomic int), int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic(const volatile _Atomic int), const int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic(int* restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_volatile_atomic(int* const restrict), int* const restrict));
static_assert(meta_is_same_type(meta_drop_volatile_atomic(int* volatile restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_volatile_atomic(int* const volatile restrict), int* const restrict));
static_assert(meta_is_same_type(meta_drop_volatile_atomic(int* _Atomic restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_volatile_atomic(int* const _Atomic restrict), int* const restrict));
static_assert(meta_is_same_type(meta_drop_volatile_atomic(int* volatile _Atomic restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_volatile_atomic(int* const volatile _Atomic restrict), int* const restrict));

static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(const int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(volatile int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(const volatile int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(_Atomic int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(const _Atomic int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(volatile _Atomic int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(const volatile _Atomic int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(int* restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(int* const restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(int* volatile restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(int* const volatile restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(int* _Atomic restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(int* const _Atomic restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(int* volatile _Atomic restrict), int* restrict));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic(int* const volatile _Atomic restrict), int* restrict));

static_assert(meta_is_same_type(meta_drop_restrict(int), int));
static_assert(meta_is_same_type(meta_drop_restrict(const int), const int));
static_assert(meta_is_same_type(meta_drop_restrict(volatile int), volatile int));
static_assert(meta_is_same_type(meta_drop_restrict(const volatile int), const volatile int));
static_assert(meta_is_same_type(meta_drop_restrict(_Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_restrict(const _Atomic int), const _Atomic int));
static_assert(meta_is_same_type(meta_drop_restrict(volatile _Atomic int), volatile _Atomic int));
static_assert(meta_is_same_type(meta_drop_restrict(const volatile _Atomic int), const volatile _Atomic int));
static_assert(meta_is_same_type(meta_drop_restrict(int* restrict), int*));
static_assert(meta_is_same_type(meta_drop_restrict(int* const restrict), int* const));
static_assert(meta_is_same_type(meta_drop_restrict(int* volatile restrict), int* volatile));
static_assert(meta_is_same_type(meta_drop_restrict(int* const volatile restrict), int* const volatile));
static_assert(meta_is_same_type(meta_drop_restrict(int* _Atomic restrict), int* _Atomic));
static_assert(meta_is_same_type(meta_drop_restrict(int* const _Atomic restrict), int* const _Atomic));
static_assert(meta_is_same_type(meta_drop_restrict(int* volatile _Atomic restrict), int* volatile _Atomic));
static_assert(meta_is_same_type(meta_drop_restrict(int* const volatile _Atomic restrict), int* const volatile _Atomic));

static_assert(meta_is_same_type(meta_drop_const_restrict(int), int));
static_assert(meta_is_same_type(meta_drop_const_restrict(const int), int));
static_assert(meta_is_same_type(meta_drop_const_restrict(volatile int), volatile int));
static_assert(meta_is_same_type(meta_drop_const_restrict(const volatile int), volatile int));
static_assert(meta_is_same_type(meta_drop_const_restrict(_Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_const_restrict(const _Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_const_restrict(volatile _Atomic int), volatile _Atomic int));
static_assert(meta_is_same_type(meta_drop_const_restrict(const volatile _Atomic int), volatile _Atomic int));
static_assert(meta_is_same_type(meta_drop_const_restrict(int* restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_restrict(int* const restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_restrict(int* volatile restrict), int* volatile));
static_assert(meta_is_same_type(meta_drop_const_restrict(int* const volatile restrict), int* volatile));
static_assert(meta_is_same_type(meta_drop_const_restrict(int* _Atomic restrict), int* _Atomic));
static_assert(meta_is_same_type(meta_drop_const_restrict(int* const _Atomic restrict), int* _Atomic));
static_assert(meta_is_same_type(meta_drop_const_restrict(int* volatile _Atomic restrict), int* volatile _Atomic));
static_assert(meta_is_same_type(meta_drop_const_restrict(int* const volatile _Atomic restrict), int* volatile _Atomic));

static_assert(meta_is_same_type(meta_drop_volatile_restrict(int), int));
static_assert(meta_is_same_type(meta_drop_volatile_restrict(const int), const int));
static_assert(meta_is_same_type(meta_drop_volatile_restrict(volatile int), int));
static_assert(meta_is_same_type(meta_drop_volatile_restrict(const volatile int), const int));
static_assert(meta_is_same_type(meta_drop_volatile_restrict(_Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_volatile_restrict(const _Atomic int), const _Atomic int));
static_assert(meta_is_same_type(meta_drop_volatile_restrict(volatile _Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_volatile_restrict(const volatile _Atomic int), const _Atomic int));
static_assert(meta_is_same_type(meta_drop_volatile_restrict(int* restrict), int*));
static_assert(meta_is_same_type(meta_drop_volatile_restrict(int* const restrict), int* const));
static_assert(meta_is_same_type(meta_drop_volatile_restrict(int* volatile restrict), int*));
static_assert(meta_is_same_type(meta_drop_volatile_restrict(int* const volatile restrict), int* const));
static_assert(meta_is_same_type(meta_drop_volatile_restrict(int* _Atomic restrict), int* _Atomic));
static_assert(meta_is_same_type(meta_drop_volatile_restrict(int* const _Atomic restrict), int* const _Atomic));
static_assert(meta_is_same_type(meta_drop_volatile_restrict(int* volatile _Atomic restrict), int* _Atomic));
static_assert(meta_is_same_type(meta_drop_volatile_restrict(int* const volatile _Atomic restrict), int* const _Atomic));

static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(const int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(volatile int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(const volatile int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(_Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(const _Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(volatile _Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(const volatile _Atomic int), _Atomic int));
static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(int* restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(int* const restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(int* volatile restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(int* const volatile restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(int* _Atomic restrict), int* _Atomic));
static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(int* const _Atomic restrict), int* _Atomic));
static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(int* volatile _Atomic restrict), int* _Atomic));
static_assert(meta_is_same_type(meta_drop_const_volatile_restrict(int* const volatile _Atomic restrict), int* _Atomic));

static_assert(meta_is_same_type(meta_drop_atomic_restrict(int), int));
static_assert(meta_is_same_type(meta_drop_atomic_restrict(const int), const int));
static_assert(meta_is_same_type(meta_drop_atomic_restrict(volatile int), volatile int));
static_assert(meta_is_same_type(meta_drop_atomic_restrict(const volatile int), const volatile int));
static_assert(meta_is_same_type(meta_drop_atomic_restrict(_Atomic int), int));
static_assert(meta_is_same_type(meta_drop_atomic_restrict(const _Atomic int), const int));
static_assert(meta_is_same_type(meta_drop_atomic_restrict(volatile _Atomic int), volatile int));
static_assert(meta_is_same_type(meta_drop_atomic_restrict(const volatile _Atomic int), const volatile int));
static_assert(meta_is_same_type(meta_drop_atomic_restrict(int* restrict), int*));
static_assert(meta_is_same_type(meta_drop_atomic_restrict(int* const restrict), int* const));
static_assert(meta_is_same_type(meta_drop_atomic_restrict(int* volatile restrict), int* volatile));
static_assert(meta_is_same_type(meta_drop_atomic_restrict(int* const volatile restrict), int* const volatile));
static_assert(meta_is_same_type(meta_drop_atomic_restrict(int* _Atomic restrict), int*));
static_assert(meta_is_same_type(meta_drop_atomic_restrict(int* const _Atomic restrict), int* const));
static_assert(meta_is_same_type(meta_drop_atomic_restrict(int* volatile _Atomic restrict), int* volatile));
static_assert(meta_is_same_type(meta_drop_atomic_restrict(int* const volatile _Atomic restrict), int* const volatile));

static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(int), int));
static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(const int), int));
static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(volatile int), volatile int));
static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(const volatile int), volatile int));
static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(_Atomic int), int));
static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(const _Atomic int), int));
static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(volatile _Atomic int), volatile int));
static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(const volatile _Atomic int), volatile int));
static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(int* restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(int* const restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(int* volatile restrict), int* volatile));
static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(int* const volatile restrict), int* volatile));
static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(int* _Atomic restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(int* const _Atomic restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(int* volatile _Atomic restrict), int* volatile));
static_assert(meta_is_same_type(meta_drop_const_atomic_restrict(int* const volatile _Atomic restrict), int* volatile));

static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(int), int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(const int), const int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(volatile int), int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(const volatile int), const int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(_Atomic int), int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(const _Atomic int), const int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(volatile _Atomic int), int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(const volatile _Atomic int), const int));
static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(int* restrict), int*));
static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(int* const restrict), int* const));
static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(int* volatile restrict), int*));
static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(int* const volatile restrict), int* const));
static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(int* _Atomic restrict), int*));
static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(int* const _Atomic restrict), int* const));
static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(int* volatile _Atomic restrict), int*));
static_assert(meta_is_same_type(meta_drop_volatile_atomic_restrict(int* const volatile _Atomic restrict), int* const));

static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(const int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(volatile int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(const volatile int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(_Atomic int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(const _Atomic int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(volatile _Atomic int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(const volatile _Atomic int), int));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(int* restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(int* const restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(int* volatile restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(int* const volatile restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(int* _Atomic restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(int* const _Atomic restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(int* volatile _Atomic restrict), int*));
static_assert(meta_is_same_type(meta_drop_const_volatile_atomic_restrict(int* const volatile _Atomic restrict), int*));

static_assert(!meta_is_type_name(T));
typedef int T;
static_assert(meta_is_type_name(T));