Compiler Explorer

Source code

# 1 "new.cpp"
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 408 "<built-in>" 3
# 1 "<command line>" 1
# 1 "<built-in>" 2
# 1 "new.cpp" 2

# 1 "../libcxx/include\\__memory/aligned_alloc.h" 1 3
# 12 "../libcxx/include\\__memory/aligned_alloc.h" 3
# 1 "../libcxx/include\\__config" 1 3
# 13 "../libcxx/include\\__config" 3
# 1 "../libcxx/include\\__config_site" 1 3
# 46 "../libcxx/include\\__config_site" 3
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wmacro-redefined"
# 66 "../libcxx/include\\__config_site" 3
#pragma clang diagnostic pop
# 14 "../libcxx/include\\__config" 2 3
# 23 "../libcxx/include\\__config" 3
# 849 "../libcxx/include\\__config" 3
namespace std { inline namespace __1 { }}
# 13 "../libcxx/include\\__memory/aligned_alloc.h" 2 3
# 1 "../libcxx/include\\cstddef" 1 3
# 36 "../libcxx/include\\cstddef" 3
# 1 "../libcxx/include\\__assert" 1 3
# 14 "../libcxx/include\\__assert" 3
# 1 "../libcxx/include\\__verbose_abort" 1 3
# 13 "../libcxx/include\\__verbose_abort" 3
# 1 "../libcxx/include\\__availability" 1 3
# 17 "../libcxx/include\\__availability" 3
# 14 "../libcxx/include\\__verbose_abort" 2 3
# 18 "../libcxx/include\\__verbose_abort" 3

namespace std { inline namespace __1 {

[[noreturn]] __attribute__((__format__(__printf__, 1, 2)))
void __libcpp_verbose_abort(const char *__format, ...);
# 58 "../libcxx/include\\__verbose_abort" 3
}}
# 15 "../libcxx/include\\__assert" 2 3
# 18 "../libcxx/include\\__assert" 3
# 37 "../libcxx/include\\cstddef" 2 3

# 1 "../libcxx/include\\__type_traits/enable_if.h" 1 3
# 16 "../libcxx/include\\__type_traits/enable_if.h" 3

namespace std { inline namespace __1 {

template <bool, class _Tp = void>
struct enable_if {};
template <class _Tp>
struct enable_if<true, _Tp> {
  typedef _Tp type;
};

template <bool _Bp, class _Tp = void>
using __enable_if_t __attribute__((__nodebug__)) = typename enable_if<_Bp, _Tp>::type;

template <bool _Bp, class _Tp = void>
using enable_if_t = typename enable_if<_Bp, _Tp>::type;

}}
# 39 "../libcxx/include\\cstddef" 2 3
# 1 "../libcxx/include\\__type_traits/integral_constant.h" 1 3
# 16 "../libcxx/include\\__type_traits/integral_constant.h" 3

namespace std { inline namespace __1 {

template <class _Tp, _Tp __v>
struct integral_constant {
  static constexpr const _Tp value = __v;
  typedef _Tp value_type;
  typedef integral_constant type;
  __attribute__((__exclude_from_explicit_instantiation__)) constexpr operator value_type() const noexcept { return value; }

__attribute__((__exclude_from_explicit_instantiation__)) constexpr value_type operator()() const noexcept { return value; }

};

template <class _Tp, _Tp __v>
constexpr const _Tp integral_constant<_Tp, __v>::value;

typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;

template <bool _Val>
using _BoolConstant __attribute__((__nodebug__)) = integral_constant<bool, _Val>;

template <bool __b>
using bool_constant = integral_constant<bool, __b>;

}}
# 40 "../libcxx/include\\cstddef" 2 3
# 1 "../libcxx/include\\__type_traits/is_integral.h" 1 3
# 14 "../libcxx/include\\__type_traits/is_integral.h" 3
# 1 "../libcxx/include\\__type_traits/remove_cv.h" 1 3
# 13 "../libcxx/include\\__type_traits/remove_cv.h" 3
# 1 "../libcxx/include\\__type_traits/remove_const.h" 1 3
# 16 "../libcxx/include\\__type_traits/remove_const.h" 3

namespace std { inline namespace __1 {
# 29 "../libcxx/include\\__type_traits/remove_const.h" 3
template <class _Tp>
struct remove_const {
  typedef _Tp type;
};
template <class _Tp>
struct remove_const<const _Tp> {
  typedef _Tp type;
};

template <class _Tp>
using __remove_const_t = typename remove_const<_Tp>::type;

template <class _Tp>
using remove_const_t = __remove_const_t<_Tp>;

}}
# 14 "../libcxx/include\\__type_traits/remove_cv.h" 2 3
# 1 "../libcxx/include\\__type_traits/remove_volatile.h" 1 3
# 16 "../libcxx/include\\__type_traits/remove_volatile.h" 3

namespace std { inline namespace __1 {
# 29 "../libcxx/include\\__type_traits/remove_volatile.h" 3
template <class _Tp>
struct remove_volatile {
  typedef _Tp type;
};
template <class _Tp>
struct remove_volatile<volatile _Tp> {
  typedef _Tp type;
};

template <class _Tp>
using __remove_volatile_t = typename remove_volatile<_Tp>::type;

template <class _Tp>
using remove_volatile_t = __remove_volatile_t<_Tp>;

}}
# 15 "../libcxx/include\\__type_traits/remove_cv.h" 2 3
# 18 "../libcxx/include\\__type_traits/remove_cv.h" 3

namespace std { inline namespace __1 {
# 31 "../libcxx/include\\__type_traits/remove_cv.h" 3
template <class _Tp>
struct remove_cv {
  typedef __remove_volatile_t<__remove_const_t<_Tp> > type;
};

template <class _Tp>
using __remove_cv_t = __remove_volatile_t<__remove_const_t<_Tp> >;

template <class _Tp>
using remove_cv_t = __remove_cv_t<_Tp>;

}}
# 15 "../libcxx/include\\__type_traits/is_integral.h" 2 3
# 18 "../libcxx/include\\__type_traits/is_integral.h" 3

namespace std { inline namespace __1 {

template <class _Tp> struct __libcpp_is_integral { enum { value = 0 }; };
template <> struct __libcpp_is_integral<bool> { enum { value = 1 }; };
template <> struct __libcpp_is_integral<char> { enum { value = 1 }; };
template <> struct __libcpp_is_integral<signed char> { enum { value = 1 }; };
template <> struct __libcpp_is_integral<unsigned char> { enum { value = 1 }; };

template <> struct __libcpp_is_integral<wchar_t> { enum { value = 1 }; };

template <> struct __libcpp_is_integral<char8_t> { enum { value = 1 }; };

template <> struct __libcpp_is_integral<char16_t> { enum { value = 1 }; };
template <> struct __libcpp_is_integral<char32_t> { enum { value = 1 }; };
template <> struct __libcpp_is_integral<short> { enum { value = 1 }; };
template <> struct __libcpp_is_integral<unsigned short> { enum { value = 1 }; };
template <> struct __libcpp_is_integral<int> { enum { value = 1 }; };
template <> struct __libcpp_is_integral<unsigned int> { enum { value = 1 }; };
template <> struct __libcpp_is_integral<long> { enum { value = 1 }; };
template <> struct __libcpp_is_integral<unsigned long> { enum { value = 1 }; };
template <> struct __libcpp_is_integral<long long> { enum { value = 1 }; };
template <> struct __libcpp_is_integral<unsigned long long> { enum { value = 1 }; };
# 52 "../libcxx/include\\__type_traits/is_integral.h" 3
template <class _Tp>
struct is_integral : _BoolConstant<__is_integral(_Tp)> {};

template <class _Tp>
inline constexpr bool is_integral_v = __is_integral(_Tp);
# 72 "../libcxx/include\\__type_traits/is_integral.h" 3
}}
# 41 "../libcxx/include\\cstddef" 2 3
# 1 "../libcxx/include\\version" 1 3
# 231 "../libcxx/include\\version" 3
# 42 "../libcxx/include\\cstddef" 2 3

# 1 "../libcxx/include\\stddef.h" 1 3
# 43 "../libcxx/include\\stddef.h" 3

# 1 "../libc/include\\stddef.h" 1 3

# 1 "../libc/include\\cdefs.h" 1 3
# 41 "../libc/include\\cdefs.h" 3
typedef unsigned int size_t;
# 5 "../libc/include\\stddef.h" 2 3

typedef int ptrdiff_t;
# 18 "../libc/include\\stddef.h" 3
typedef struct {
    long long __max_align_ll __attribute__((__aligned__(__alignof__( long long))));
    long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));

} max_align_t;

using ::ptrdiff_t;
using ::size_t;
using ::max_align_t;
using nullptr_t = decltype(nullptr);

enum class byte : unsigned char {};

constexpr byte operator| (byte __lhs, byte __rhs) noexcept { return byte(char(__lhs) | char(__rhs)); }
constexpr byte& operator|=(byte& __lhs, byte __rhs) noexcept { return __lhs = __lhs | __rhs; }
constexpr byte operator& (byte __lhs, byte __rhs) noexcept { return byte(char(__lhs) & char(__rhs)); }
constexpr byte& operator&=(byte& __lhs, byte __rhs) noexcept { return __lhs = __lhs & __rhs; }
constexpr byte operator^ (byte __lhs, byte __rhs) noexcept { return byte(char(__lhs) ^ char(__rhs)); }
constexpr byte& operator^=(byte& __lhs, byte __rhs) noexcept { return __lhs = __lhs ^ __rhs; }
constexpr byte operator~ (byte __rhs) noexcept { return byte(~char(__rhs)); }
# 47 "../libcxx/include\\stddef.h" 2 3

typedef decltype(nullptr) nullptr_t;
# 44 "../libcxx/include\\cstddef" 2 3
# 55 "../libcxx/include\\cstddef" 3

namespace std { inline namespace __1 {

using ::nullptr_t;
using ::ptrdiff_t __attribute__((__using_if_exists__));
using ::size_t __attribute__((__using_if_exists__));

using ::max_align_t __attribute__((__using_if_exists__));

}}

namespace std
{
enum class byte : unsigned char {};

__attribute__((__exclude_from_explicit_instantiation__)) constexpr byte operator| (byte __lhs, byte __rhs) noexcept
{
    return static_cast<byte>(
      static_cast<unsigned char>(
         static_cast<unsigned int>(__lhs) | static_cast<unsigned int>(__rhs)
    ));
}

__attribute__((__exclude_from_explicit_instantiation__)) constexpr byte& operator|=(byte& __lhs, byte __rhs) noexcept
{ return __lhs = __lhs | __rhs; }

__attribute__((__exclude_from_explicit_instantiation__)) constexpr byte operator& (byte __lhs, byte __rhs) noexcept
{
    return static_cast<byte>(
      static_cast<unsigned char>(
         static_cast<unsigned int>(__lhs) & static_cast<unsigned int>(__rhs)
    ));
}

__attribute__((__exclude_from_explicit_instantiation__)) constexpr byte& operator&=(byte& __lhs, byte __rhs) noexcept
{ return __lhs = __lhs & __rhs; }

__attribute__((__exclude_from_explicit_instantiation__)) constexpr byte operator^ (byte __lhs, byte __rhs) noexcept
{
    return static_cast<byte>(
      static_cast<unsigned char>(
         static_cast<unsigned int>(__lhs) ^ static_cast<unsigned int>(__rhs)
    ));
}

__attribute__((__exclude_from_explicit_instantiation__)) constexpr byte& operator^=(byte& __lhs, byte __rhs) noexcept
{ return __lhs = __lhs ^ __rhs; }

__attribute__((__exclude_from_explicit_instantiation__)) constexpr byte operator~ (byte __b) noexcept
{
    return static_cast<byte>(
      static_cast<unsigned char>(
        ~static_cast<unsigned int>(__b)
    ));
}

template <class _Tp>
using _EnableByteOverload = __enable_if_t<is_integral<_Tp>::value, byte>;

template <class _Integer>
 __attribute__((__exclude_from_explicit_instantiation__)) constexpr _EnableByteOverload<_Integer> &
  operator<<=(byte& __lhs, _Integer __shift) noexcept
  { return __lhs = __lhs << __shift; }

template <class _Integer>
 __attribute__((__exclude_from_explicit_instantiation__)) constexpr _EnableByteOverload<_Integer>
  operator<< (byte __lhs, _Integer __shift) noexcept
  { return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(__lhs) << __shift)); }

template <class _Integer>
 __attribute__((__exclude_from_explicit_instantiation__)) constexpr _EnableByteOverload<_Integer> &
  operator>>=(byte& __lhs, _Integer __shift) noexcept
  { return __lhs = __lhs >> __shift; }

template <class _Integer>
 __attribute__((__exclude_from_explicit_instantiation__)) constexpr _EnableByteOverload<_Integer>
  operator>> (byte __lhs, _Integer __shift) noexcept
  { return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(__lhs) >> __shift)); }

template <class _Integer, class = _EnableByteOverload<_Integer> >
[[__nodiscard__]] __attribute__((__exclude_from_explicit_instantiation__)) constexpr _Integer
  to_integer(byte __b) noexcept { return static_cast<_Integer>(__b); }

}
# 14 "../libcxx/include\\__memory/aligned_alloc.h" 2 3
# 1 "../libcxx/include\\cstdlib" 1 3
# 87 "../libcxx/include\\cstdlib" 3
# 1 "../libcxx/include\\stdlib.h" 1 3
# 91 "../libcxx/include\\stdlib.h" 3

# 1 "../libc/include\\stdlib.h" 1 3

# 1 "../libc/include\\__wchar_def.h" 1 3
# 15 "../libc/include\\__wchar_def.h" 3
typedef int wint_t;
# 6 "../libc/include\\stdlib.h" 2 3
# 1 "../libc/include\\__stdlib_abs.h" 1 3

extern "C" {

int abs(int);

long labs(long);

signed __int48 i48abs(signed __int48 n) noexcept __attribute__((__const__));

long long llabs(long long);

}
# 7 "../libc/include\\stdlib.h" 2 3

# 1 "../libc/include\\__cxx_abs.h" 1 3

# 1 "../libc/include\\__math_abs.h" 1 3

extern "C" {

float fabsf(float);

double fabs(double);

long double fabsl(long double);

}
# 6 "../libc/include\\__cxx_abs.h" 2 3

namespace std {
using ::abs;

inline constexpr long abs(long __x) { return labs(__x); }

inline signed __int48 abs(signed __int48 __x) { return i48abs(__x); }

inline constexpr long long abs(long long __x) { return llabs(__x); }

}
# 10 "../libc/include\\stdlib.h" 2 3

typedef struct {
    int quot;
    int rem;
} div_t;

typedef struct {
    long quot;
    long rem;
} ldiv_t;

typedef struct {
    signed __int48 quot;
    signed __int48 rem;
} i48div_t;

typedef struct {
    long long rem;
    long long quot;
} lldiv_t;
# 41 "../libc/include\\stdlib.h" 3
extern "C" {

void *calloc(size_t nmemb, size_t size) __attribute__((malloc));

void *malloc(size_t size) __attribute__((malloc));

void *realloc(void *ptr, size_t size) __attribute__((warn_unused_result));

void free(void *ptr) noexcept;

double atof(const char *nptr) __attribute__((nonnull(1)));

int atoi(const char *nptr) __attribute__((nonnull(1)));

long atol(const char *nptr) __attribute__((nonnull(1)));

long long atoll(const char *nptr) __attribute__((nonnull(1)));

float strtof(const char *__restrict nptr,
             char **__restrict endptr) __attribute__((nonnull(1)));

double strtod(const char *__restrict nptr,
              char **__restrict endptr) __attribute__((nonnull(1)));

long double strtold(const char *__restrict nptr,
                    char **__restrict endptr) __attribute__((nonnull(1)));

long strtol(const char *__restrict nptr,
            char **__restrict endptr, int base) __attribute__((nonnull(1)));

long long strtoll(const char *__restrict nptr,
                  char **__restrict endptr,
                  int base) __attribute__((nonnull(1)));

unsigned long strtoul(const char *__restrict nptr,
                      char **__restrict endptr, int base)
                      __attribute__((nonnull(1)));

unsigned long long strtoull(const char *__restrict nptr,
                            char **__restrict endptr, int base)
                            __attribute__((nonnull(1)));

void srand(unsigned int seed);

int rand(void);

void *bsearch(const void *key, const void *base, size_t nmemb, size_t size,
              int (*compar)(const void *, const void *))
              __attribute__((nonnull(1, 2, 5)));

void qsort(void *base, size_t nmemb, size_t size,
           int (*compar)(const void *, const void *))
           __attribute__((nonnull(1, 4)));

void abort(void) noexcept __attribute__((noreturn));

int atexit(void (*)(void)) noexcept;

int on_exit(void (*)(int, void *), void *) noexcept;

void exit(int) noexcept __attribute__((noreturn));

int at_quick_exit(void (*)(void)) noexcept;

void quick_exit(int) noexcept __attribute__((noreturn));

void _Exit(int) noexcept __attribute__((noreturn));

div_t div(int numer, int denom);

ldiv_t ldiv(long numer, long denom);

lldiv_t lldiv(long long numer, long long denom);

i48div_t i48div(signed __int48 numer, signed __int48 denom) noexcept __attribute__((__const__));

int mblen(const char* s, size_t n);
int mbtowc(wchar_t* pwc, const char* s, size_t n);
int wctomb(char* s, wchar_t wchar);
size_t mbstowcs(wchar_t* pwcs, const char* s, size_t n);
size_t wcstombs(char* s, const wchar_t* pwcs, size_t n);

}
# 95 "../libcxx/include\\stdlib.h" 2 3

extern "C++" {
# 113 "../libcxx/include\\stdlib.h" 3
[[__nodiscard__]] inline __attribute__((__exclude_from_explicit_instantiation__)) long abs(long __x) noexcept {
  return __builtin_labs(__x);
}
[[__nodiscard__]] inline __attribute__((__exclude_from_explicit_instantiation__)) long long abs(long long __x) noexcept {
  return __builtin_llabs(__x);
}

[[__nodiscard__]] inline __attribute__((__exclude_from_explicit_instantiation__)) float abs(float __lcpp_x) noexcept {
  return __builtin_fabsf(__lcpp_x);
}

[[__nodiscard__]] inline __attribute__((__exclude_from_explicit_instantiation__)) double abs(double __lcpp_x) noexcept {
  return __builtin_fabs(__lcpp_x);
}

[[__nodiscard__]] inline __attribute__((__exclude_from_explicit_instantiation__)) long double
abs(long double __lcpp_x) noexcept {
  return __builtin_fabsl(__lcpp_x);
}
# 148 "../libcxx/include\\stdlib.h" 3
inline __attribute__((__exclude_from_explicit_instantiation__)) ldiv_t div(long __x, long __y) noexcept {
  return ::ldiv(__x, __y);
}

inline __attribute__((__exclude_from_explicit_instantiation__)) lldiv_t div(long long __x,
                                             long long __y) noexcept {
  return ::lldiv(__x, __y);
}

}
# 88 "../libcxx/include\\cstdlib" 2 3
# 99 "../libcxx/include\\cstdlib" 3

namespace std { inline namespace __1 {

using ::size_t __attribute__((__using_if_exists__));
using ::div_t __attribute__((__using_if_exists__));
using ::ldiv_t __attribute__((__using_if_exists__));
using ::lldiv_t __attribute__((__using_if_exists__));
using ::atof __attribute__((__using_if_exists__));
using ::atoi __attribute__((__using_if_exists__));
using ::atol __attribute__((__using_if_exists__));
using ::atoll __attribute__((__using_if_exists__));
using ::strtod __attribute__((__using_if_exists__));
using ::strtof __attribute__((__using_if_exists__));
using ::strtold __attribute__((__using_if_exists__));
using ::strtol __attribute__((__using_if_exists__));
using ::strtoll __attribute__((__using_if_exists__));
using ::strtoul __attribute__((__using_if_exists__));
using ::strtoull __attribute__((__using_if_exists__));
using ::rand __attribute__((__using_if_exists__));
using ::srand __attribute__((__using_if_exists__));
using ::calloc __attribute__((__using_if_exists__));
using ::free __attribute__((__using_if_exists__));
using ::malloc __attribute__((__using_if_exists__));
using ::realloc __attribute__((__using_if_exists__));
using ::abort __attribute__((__using_if_exists__));
using ::atexit __attribute__((__using_if_exists__));
using ::exit __attribute__((__using_if_exists__));
using ::_Exit __attribute__((__using_if_exists__));
using ::getenv __attribute__((__using_if_exists__));
using ::system __attribute__((__using_if_exists__));
using ::bsearch __attribute__((__using_if_exists__));
using ::qsort __attribute__((__using_if_exists__));
using ::abs __attribute__((__using_if_exists__));
using ::labs __attribute__((__using_if_exists__));
using ::llabs __attribute__((__using_if_exists__));
using ::div __attribute__((__using_if_exists__));
using ::ldiv __attribute__((__using_if_exists__));
using ::lldiv __attribute__((__using_if_exists__));
using ::mblen __attribute__((__using_if_exists__));
using ::mbtowc __attribute__((__using_if_exists__));
using ::wctomb __attribute__((__using_if_exists__));
using ::mbstowcs __attribute__((__using_if_exists__));
using ::wcstombs __attribute__((__using_if_exists__));

using ::at_quick_exit __attribute__((__using_if_exists__));
using ::quick_exit __attribute__((__using_if_exists__));

using ::aligned_alloc __attribute__((__using_if_exists__));

}}
# 15 "../libcxx/include\\__memory/aligned_alloc.h" 2 3
# 18 "../libcxx/include\\__memory/aligned_alloc.h" 3

namespace std { inline namespace __1 {
# 64 "../libcxx/include\\__memory/aligned_alloc.h" 3
}}
# 10 "new.cpp" 2

# 1 "../libcxx/include\\new" 1 3
# 92 "../libcxx/include\\new" 3
# 1 "../libcxx/include\\__exception/exception.h" 1 3
# 22 "../libcxx/include\\__exception/exception.h" 3

namespace std {
# 72 "../libcxx/include\\__exception/exception.h" 3
class exception {
public:
  __attribute__((__exclude_from_explicit_instantiation__)) exception() noexcept {}
  __attribute__((__exclude_from_explicit_instantiation__)) exception(const exception&) noexcept = default;

virtual ~exception() noexcept;
  virtual const char* what() const noexcept;
};

class bad_exception : public exception {
public:
  __attribute__((__exclude_from_explicit_instantiation__)) bad_exception() noexcept {}
  ~bad_exception() noexcept override;
  const char* what() const noexcept override;
};

}
# 93 "../libcxx/include\\new" 2 3
# 1 "../libcxx/include\\__type_traits/alignment_of.h" 1 3
# 18 "../libcxx/include\\__type_traits/alignment_of.h" 3

namespace std { inline namespace __1 {

template <class _Tp>
struct alignment_of : public integral_constant<size_t, alignof(_Tp)> {};

template <class _Tp>
inline constexpr size_t alignment_of_v = alignof(_Tp);

}}
# 94 "../libcxx/include\\new" 2 3
# 1 "../libcxx/include\\__type_traits/is_function.h" 1 3
# 14 "../libcxx/include\\__type_traits/is_function.h" 3
# 1 "../libcxx/include\\__type_traits/is_const.h" 1 3
# 17 "../libcxx/include\\__type_traits/is_const.h" 3

namespace std { inline namespace __1 {

template <class _Tp>
struct is_const : _BoolConstant<__is_const(_Tp)> {};

template <class _Tp>
inline constexpr bool is_const_v = __is_const(_Tp);
# 45 "../libcxx/include\\__type_traits/is_const.h" 3
}}
# 15 "../libcxx/include\\__type_traits/is_function.h" 2 3
# 1 "../libcxx/include\\__type_traits/is_reference.h" 1 3
# 17 "../libcxx/include\\__type_traits/is_reference.h" 3

namespace std { inline namespace __1 {

template <class _Tp>
struct is_lvalue_reference : _BoolConstant<__is_lvalue_reference(_Tp)> {};

template <class _Tp>
struct is_rvalue_reference : _BoolConstant<__is_rvalue_reference(_Tp)> {};

template <class _Tp>
struct is_reference : _BoolConstant<__is_reference(_Tp)> {};

template <class _Tp>
inline constexpr bool is_reference_v = __is_reference(_Tp);
template <class _Tp>
inline constexpr bool is_lvalue_reference_v = __is_lvalue_reference(_Tp);
template <class _Tp>
inline constexpr bool is_rvalue_reference_v = __is_rvalue_reference(_Tp);
# 73 "../libcxx/include\\__type_traits/is_reference.h" 3
}}
# 16 "../libcxx/include\\__type_traits/is_function.h" 2 3
# 19 "../libcxx/include\\__type_traits/is_function.h" 3

namespace std { inline namespace __1 {

template <class _Tp>
struct is_function : integral_constant<bool, __is_function(_Tp)> {};
# 37 "../libcxx/include\\__type_traits/is_function.h" 3
template <class _Tp>
inline constexpr bool is_function_v = is_function<_Tp>::value;

}}
# 95 "../libcxx/include\\new" 2 3
# 1 "../libcxx/include\\__type_traits/is_same.h" 1 3
# 17 "../libcxx/include\\__type_traits/is_same.h" 3

namespace std { inline namespace __1 {

template <class _Tp, class _Up>
struct is_same : _BoolConstant<__is_same(_Tp, _Up)> {};

template <class _Tp, class _Up>
inline constexpr bool is_same_v = __is_same(_Tp, _Up);
# 36 "../libcxx/include\\__type_traits/is_same.h" 3
template <class _Tp, class _Up>
using _IsSame = _BoolConstant<__is_same(_Tp, _Up)>;

template <class _Tp, class _Up>
using _IsNotSame = _BoolConstant<!__is_same(_Tp, _Up)>;

}}
# 96 "../libcxx/include\\new" 2 3
# 108 "../libcxx/include\\new" 3
# 124 "../libcxx/include\\new" 3
namespace std
{

struct nothrow_t { explicit nothrow_t() = default; };
extern const nothrow_t nothrow;

class bad_alloc
    : public exception
{
public:
    bad_alloc() noexcept;
    ~bad_alloc() noexcept override;
    const char* what() const noexcept override;
};

class bad_array_new_length
    : public bad_alloc
{
public:
    bad_array_new_length() noexcept;
    ~bad_array_new_length() noexcept override;
    const char* what() const noexcept override;
};

typedef void (*new_handler)();
                          new_handler set_new_handler(new_handler) noexcept;
                          new_handler get_new_handler() noexcept;
# 173 "../libcxx/include\\new" 3
[[noreturn]] void __throw_bad_alloc();

[[noreturn]] inline __attribute__((__exclude_from_explicit_instantiation__))
void __throw_bad_array_new_length()
{

::std::__libcpp_verbose_abort("bad_array_new_length was thrown in -fno-exceptions mode");

}
# 197 "../libcxx/include\\new" 3
struct destroying_delete_t {
  explicit destroying_delete_t() = default;
};
inline constexpr destroying_delete_t destroying_delete{};

}
# 213 "../libcxx/include\\new" 3
[[__nodiscard__]] void* operator new(std::size_t __sz) ;
[[__nodiscard__]] void* operator new(std::size_t __sz, const std::nothrow_t&) noexcept __attribute__((__malloc__));
                             void operator delete(void* __p) noexcept;
                             void operator delete(void* __p, const std::nothrow_t&) noexcept;

void operator delete(void* __p, std::size_t __sz) noexcept;

[[__nodiscard__]] void* operator new[](std::size_t __sz) ;
[[__nodiscard__]] void* operator new[](std::size_t __sz, const std::nothrow_t&) noexcept __attribute__((__malloc__));
                             void operator delete[](void* __p) noexcept;
                             void operator delete[](void* __p, const std::nothrow_t&) noexcept;

void operator delete[](void* __p, std::size_t __sz) noexcept;
# 247 "../libcxx/include\\new" 3
[[__nodiscard__]] inline __attribute__((__exclude_from_explicit_instantiation__)) void* operator new (std::size_t, void* __p) noexcept {return __p;}
[[__nodiscard__]] inline __attribute__((__exclude_from_explicit_instantiation__)) void* operator new[](std::size_t, void* __p) noexcept {return __p;}
inline __attribute__((__exclude_from_explicit_instantiation__)) void operator delete (void*, void*) noexcept {}
inline __attribute__((__exclude_from_explicit_instantiation__)) void operator delete[](void*, void*) noexcept {}

namespace std { inline namespace __1 {

constexpr inline __attribute__((__exclude_from_explicit_instantiation__)) bool __is_overaligned_for_new(size_t __align) noexcept {

return __align > 1U;

}

template <class ..._Args>
 __attribute__((__exclude_from_explicit_instantiation__))
void* __libcpp_operator_new(_Args ...__args) {

return __builtin_operator_new(__args...);

}

template <class ..._Args>
 __attribute__((__exclude_from_explicit_instantiation__))
void __libcpp_operator_delete(_Args ...__args) {

__builtin_operator_delete(__args...);

}

inline __attribute__((__exclude_from_explicit_instantiation__))
void *__libcpp_allocate(size_t __size, size_t __align) {

(void)__align;
  return __libcpp_operator_new(__size);
}

template <class ..._Args>
 __attribute__((__exclude_from_explicit_instantiation__))
void __do_deallocate_handle_size(void *__ptr, size_t __size, _Args ...__args) {

(void)__size;
  return std::__libcpp_operator_delete(__ptr, __args...);

}

inline __attribute__((__exclude_from_explicit_instantiation__))
void __libcpp_deallocate(void* __ptr, size_t __size, size_t __align) {

(void)__align;
    return __do_deallocate_handle_size(__ptr, __size);
# 321 "../libcxx/include\\new" 3
}

inline __attribute__((__exclude_from_explicit_instantiation__)) void __libcpp_deallocate_unsized(void* __ptr, size_t __align) {

(void)__align;
    return __libcpp_operator_delete(__ptr);
# 335 "../libcxx/include\\new" 3
}

template <class _Tp>
[[__nodiscard__]] inline __attribute__((__exclude_from_explicit_instantiation__))
constexpr _Tp* __launder(_Tp* __p) noexcept
{
    static_assert (!(is_function<_Tp>::value), "can't launder functions" );
    static_assert (!(is_same<void, __remove_cv_t<_Tp> >::value), "can't launder cv-void" );
    return __builtin_launder(__p);
}

template <class _Tp>
[[__nodiscard__]] inline __attribute__((__exclude_from_explicit_instantiation__))
constexpr _Tp* launder(_Tp* __p) noexcept
{
    return std::__launder(__p);
}
# 366 "../libcxx/include\\new" 3
}}
# 12 "new.cpp" 2
# 23 "new.cpp"
__attribute__((__weak__))
void *
operator new(std::size_t size)
{
    if (size == 0)
        size = 1;
    void* p;
    while ((p = std::malloc(size)) == nullptr)
    {

std::new_handler nh = std::get_new_handler();
        if (nh)
            nh();
        else

break;

}
    return p;
}

__attribute__((__weak__))
void*
operator new(size_t size, const std::nothrow_t&) noexcept
{
    void* p = nullptr;

p = ::operator new(size);

return p;
}

__attribute__((__weak__))
void*
operator new[](size_t size)
{
    return ::operator new(size);
}

__attribute__((__weak__))
void*
operator new[](size_t size, const std::nothrow_t&) noexcept
{
    void* p = nullptr;

p = ::operator new[](size);

return p;
}

__attribute__((__weak__))
void
operator delete(void* ptr) noexcept
{
    std::free(ptr);
}

__attribute__((__weak__))
void
operator delete(void* ptr, const std::nothrow_t&) noexcept
{
    ::operator delete(ptr);
}

__attribute__((__weak__))
void
operator delete(void* ptr, size_t) noexcept
{
    ::operator delete(ptr);
}

__attribute__((__weak__))
void
operator delete[] (void* ptr) noexcept
{
    ::operator delete(ptr);
}

__attribute__((__weak__))
void
operator delete[] (void* ptr, const std::nothrow_t&) noexcept
{
    ::operator delete[](ptr);
}

__attribute__((__weak__))
void
operator delete[] (void* ptr, size_t) noexcept
{
    ::operator delete[](ptr);
}