clang/test/Analysis/Inputs/system-header-simulator-cxx.h

   1 // Like the compiler, the static analyzer treats some functions differently if
   2 // they come from a system header -- for example, it is assumed that system
   3 // functions do not arbitrarily free() their parameters, and that some bugs
   4 // found in system headers cannot be fixed by the user and should be
   5 // suppressed.
   6 #pragma clang system_header
   7
   8 typedef unsigned char uint8_t;
   9
  10 typedef __typeof__(sizeof(int)) size_t;
  11 typedef __typeof__((char*)0-(char*)0) ptrdiff_t;
  12 void *memmove(void *s1, const void *s2, size_t n);
  13
  14 namespace std {
  15   typedef size_t size_type;
  16 #if __cplusplus >= 201103L
  17   using nullptr_t = decltype(nullptr);
  18 #endif
  19 }
  20
  21 namespace std {
  22   struct input_iterator_tag { };
  23   struct output_iterator_tag { };
  24   struct forward_iterator_tag : public input_iterator_tag { };
  25   struct bidirectional_iterator_tag : public forward_iterator_tag { };
  26   struct random_access_iterator_tag : public bidirectional_iterator_tag { };
  27
  28   template <typename Iterator> struct iterator_traits {
  29     typedef typename Iterator::difference_type difference_type;
  30     typedef typename Iterator::value_type value_type;
  31     typedef typename Iterator::pointer pointer;
  32     typedef typename Iterator::reference reference;
  33     typedef typename Iterator::iterator_category iterator_category;
  34   };
  35 }
  36
  37 template <typename T, typename Ptr, typename Ref> struct __vector_iterator {
  38   typedef __vector_iterator<T, T *, T &> iterator;
  39   typedef __vector_iterator<T, const T *, const T &> const_iterator;
  40
  41   typedef ptrdiff_t difference_type;
  42   typedef T value_type;
  43   typedef Ptr pointer;
  44   typedef Ref reference;
  45   typedef std::random_access_iterator_tag iterator_category;
  46
  47   __vector_iterator(const Ptr p = 0) : ptr(p) {}
  48   __vector_iterator(const iterator &rhs): ptr(rhs.base()) {}
  49   __vector_iterator<T, Ptr, Ref>& operator++() { ++ ptr; return *this; }
  50   __vector_iterator<T, Ptr, Ref> operator++(int) {
  51     auto tmp = *this;
  52     ++ ptr;
  53     return tmp;
  54   }
  55   __vector_iterator<T, Ptr, Ref> operator--() { -- ptr; return *this; }
  56   __vector_iterator<T, Ptr, Ref> operator--(int) {
  57     auto tmp = *this; -- ptr;
  58     return tmp;
  59   }
  60   __vector_iterator<T, Ptr, Ref> operator+(difference_type n) {
  61     return ptr + n;
  62   }
  63   friend __vector_iterator<T, Ptr, Ref> operator+(
  64       difference_type n,
  65       const __vector_iterator<T, Ptr, Ref> &iter) {
  66     return n + iter.ptr;
  67   }
  68   __vector_iterator<T, Ptr, Ref> operator-(difference_type n) {
  69     return ptr - n;
  70   }
  71   __vector_iterator<T, Ptr, Ref> operator+=(difference_type n) {
  72     return ptr += n;
  73   }
  74   __vector_iterator<T, Ptr, Ref> operator-=(difference_type n) {
  75     return ptr -= n;
  76   }
  77
  78   template<typename U, typename Ptr2, typename Ref2>
  79   difference_type operator-(const __vector_iterator<U, Ptr2, Ref2> &rhs);
  80
  81   Ref operator*() const { return *ptr; }
  82   Ptr operator->() const { return ptr; }
  83
  84   Ref operator[](difference_type n) {
  85     return *(ptr+n);
  86   }
  87
  88   bool operator==(const iterator &rhs) const { return ptr == rhs.ptr; }
  89   bool operator==(const const_iterator &rhs) const { return ptr == rhs.ptr; }
  90
  91   bool operator!=(const iterator &rhs) const { return ptr != rhs.ptr; }
  92   bool operator!=(const const_iterator &rhs) const { return ptr != rhs.ptr; }
  93
  94   const Ptr& base() const { return ptr; }
  95
  96 private:
  97   Ptr ptr;
  98 };
  99
 100 template <typename T, typename Ptr, typename Ref> struct __deque_iterator {
 101   typedef __deque_iterator<T, T *, T &> iterator;
 102   typedef __deque_iterator<T, const T *, const T &> const_iterator;
 103
 104   typedef ptrdiff_t difference_type;
 105   typedef T value_type;
 106   typedef Ptr pointer;
 107   typedef Ref reference;
 108   typedef std::random_access_iterator_tag iterator_category;
 109
 110   __deque_iterator(const Ptr p = 0) : ptr(p) {}
 111   __deque_iterator(const iterator &rhs): ptr(rhs.base()) {}
 112   __deque_iterator<T, Ptr, Ref>& operator++() { ++ ptr; return *this; }
 113   __deque_iterator<T, Ptr, Ref> operator++(int) {
 114     auto tmp = *this;
 115     ++ ptr;
 116     return tmp;
 117   }
 118   __deque_iterator<T, Ptr, Ref> operator--() { -- ptr; return *this; }
 119   __deque_iterator<T, Ptr, Ref> operator--(int) {
 120     auto tmp = *this; -- ptr;
 121     return tmp;
 122   }
 123   __deque_iterator<T, Ptr, Ref> operator+(difference_type n) {
 124     return ptr + n;
 125   }
 126   friend __deque_iterator<T, Ptr, Ref> operator+(
 127       difference_type n,
 128       const __deque_iterator<T, Ptr, Ref> &iter) {
 129     return n + iter.ptr;
 130   }
 131   __deque_iterator<T, Ptr, Ref> operator-(difference_type n) {
 132     return ptr - n;
 133   }
 134   __deque_iterator<T, Ptr, Ref> operator+=(difference_type n) {
 135     return ptr += n;
 136   }
 137   __deque_iterator<T, Ptr, Ref> operator-=(difference_type n) {
 138     return ptr -= n;
 139   }
 140
 141   Ref operator*() const { return *ptr; }
 142   Ptr operator->() const { return ptr; }
 143
 144   Ref operator[](difference_type n) {
 145     return *(ptr+n);
 146   }
 147
 148   bool operator==(const iterator &rhs) const { return ptr == rhs.ptr; }
 149   bool operator==(const const_iterator &rhs) const { return ptr == rhs.ptr; }
 150
 151   bool operator!=(const iterator &rhs) const { return ptr != rhs.ptr; }
 152   bool operator!=(const const_iterator &rhs) const { return ptr != rhs.ptr; }
 153
 154   const Ptr& base() const { return ptr; }
 155
 156 private:
 157   Ptr ptr;
 158 };
 159
 160 template <typename T, typename Ptr, typename Ref> struct __list_iterator {
 161   typedef __list_iterator<T, __typeof__(T::data) *, __typeof__(T::data) &> iterator;
 162   typedef __list_iterator<T, const __typeof__(T::data) *, const __typeof__(T::data) &> const_iterator;
 163
 164   typedef ptrdiff_t difference_type;
 165   typedef T value_type;
 166   typedef Ptr pointer;
 167   typedef Ref reference;
 168   typedef std::bidirectional_iterator_tag iterator_category;
 169
 170   __list_iterator(T* it = 0) : item(it) {}
 171   __list_iterator(const iterator &rhs): item(rhs.item) {}
 172   __list_iterator<T, Ptr, Ref>& operator++() { item = item->next; return *this; }
 173   __list_iterator<T, Ptr, Ref> operator++(int) {
 174     auto tmp = *this;
 175     item = item->next;
 176     return tmp;
 177   }
 178   __list_iterator<T, Ptr, Ref> operator--() { item = item->prev; return *this; }
 179   __list_iterator<T, Ptr, Ref> operator--(int) {
 180     auto tmp = *this;
 181     item = item->prev;
 182     return tmp;
 183   }
 184
 185   Ref operator*() const { return item->data; }
 186   Ptr operator->() const { return &item->data; }
 187
 188   bool operator==(const iterator &rhs) const { return item == rhs->item; }
 189   bool operator==(const const_iterator &rhs) const { return item == rhs->item; }
 190
 191   bool operator!=(const iterator &rhs) const { return item != rhs->item; }
 192   bool operator!=(const const_iterator &rhs) const { return item != rhs->item; }
 193
 194   const T* &base() const { return item; }
 195
 196   template <typename UT, typename UPtr, typename URef>
 197   friend struct __list_iterator;
 198
 199 private:
 200   T* item;
 201 };
 202
 203 template <typename T, typename Ptr, typename Ref> struct __fwdl_iterator {
 204   typedef __fwdl_iterator<T, __typeof__(T::data) *, __typeof__(T::data) &> iterator;
 205   typedef __fwdl_iterator<T, const __typeof__(T::data) *, const __typeof__(T::data) &> const_iterator;
 206
 207   typedef ptrdiff_t difference_type;
 208   typedef T value_type;
 209   typedef Ptr pointer;
 210   typedef Ref reference;
 211   typedef std::forward_iterator_tag iterator_category;
 212
 213   __fwdl_iterator(T* it = 0) : item(it) {}
 214   __fwdl_iterator(const iterator &rhs): item(rhs.item) {}
 215   __fwdl_iterator<T, Ptr, Ref>& operator++() { item = item->next; return *this; }
 216   __fwdl_iterator<T, Ptr, Ref> operator++(int) {
 217     auto tmp = *this;
 218     item = item->next;
 219     return tmp;
 220   }
 221   Ref operator*() const { return item->data; }
 222   Ptr operator->() const { return &item->data; }
 223
 224   bool operator==(const iterator &rhs) const { return item == rhs->item; }
 225   bool operator==(const const_iterator &rhs) const { return item == rhs->item; }
 226
 227   bool operator!=(const iterator &rhs) const { return item != rhs->item; }
 228   bool operator!=(const const_iterator &rhs) const { return item != rhs->item; }
 229
 230   const T* &base() const { return item; }
 231
 232   template <typename UT, typename UPtr, typename URef>
 233   friend struct __fwdl_iterator;
 234
 235 private:
 236   T* item;
 237 };
 238
 239 namespace std {
 240   template <class T1, class T2>
 241   struct pair {
 242     T1 first;
 243     T2 second;
 244
 245     pair() : first(), second() {}
 246     pair(const T1 &a, const T2 &b) : first(a), second(b) {}
 247
 248     template<class U1, class U2>
 249     pair(const pair<U1, U2> &other) : first(other.first),
 250                                       second(other.second) {}
 251   };
 252
 253   template<class T2, class T1>
 254   T2& get(pair<T1, T2>& p) ;
 255   template<class T1, class T2>
 256   T1& get(const pair<T1, T2>& p) ;
 257
 258   typedef __typeof__(sizeof(int)) size_t;
 259
 260   template <class T> class initializer_list;
 261
 262   template< class T > struct remove_reference      {typedef T type;};
 263   template< class T > struct remove_reference<T&>  {typedef T type;};
 264   template< class T > struct remove_reference<T&&> {typedef T type;};
 265
 266   template<typename T> typename remove_reference<T>::type&& move(T&& a);
 267   template <typename T> T *__addressof(T &x);
 268   template <typename T> T *addressof(T &x);
 269   template <typename T> const T& as_const(T& x);
 270   template <typename T> T&& forward(T&& x);
 271   // FIXME: Declare forward_like
 272   // FIXME: Declare move_if_noexcept
 273
 274   template< class T >
 275   using remove_reference_t = typename remove_reference<T>::type;
 276
 277   template <class T>
 278   void swap(T &a, T &b) {
 279     T c(std::move(a));
 280     a = std::move(b);
 281     b = std::move(c);
 282   }
 283
 284   template<typename T>
 285   class vector {
 286     T *_start;
 287     T *_finish;
 288     T *_end_of_storage;
 289
 290   public:
 291     typedef T value_type;
 292     typedef size_t size_type;
 293     typedef __vector_iterator<T, T *, T &> iterator;
 294     typedef __vector_iterator<T, const T *, const T &> const_iterator;
 295
 296     vector() : _start(0), _finish(0), _end_of_storage(0) {}
 297     template <typename InputIterator>
 298     vector(InputIterator first, InputIterator last);
 299     vector(const vector &other);
 300     vector(vector &&other);
 301     ~vector();
 302
 303     size_t size() const {
 304       return size_t(_finish - _start);
 305     }
 306
 307     vector& operator=(const vector &other);
 308     vector& operator=(vector &&other);
 309     vector& operator=(std::initializer_list<T> ilist);
 310
 311     void assign(size_type count, const T &value);
 312     template <typename InputIterator >
 313     void assign(InputIterator first, InputIterator last);
 314     void assign(std::initializer_list<T> ilist);
 315
 316     void clear();
 317
 318     void push_back(const T &value);
 319     void push_back(T &&value);
 320     template<class... Args>
 321     void emplace_back(Args&&... args);
 322     void pop_back();
 323
 324     iterator insert(const_iterator position, const value_type &val);
 325     iterator insert(const_iterator position, size_type n,
 326                     const value_type &val);
 327     template <typename InputIterator>
 328     iterator insert(const_iterator position, InputIterator first,
 329                     InputIterator last);
 330     iterator insert(const_iterator position, value_type &&val);
 331     iterator insert(const_iterator position, initializer_list<value_type> il);
 332
 333     template <class... Args>
 334     iterator emplace(const_iterator position, Args&&... args);
 335
 336     iterator erase(const_iterator position);
 337     iterator erase(const_iterator first, const_iterator last);
 338
 339     T &operator[](size_t n) {
 340       return _start[n];
 341     }
 342
 343     const T &operator[](size_t n) const {
 344       return _start[n];
 345     }
 346
 347     iterator begin() { return iterator(_start); }
 348     const_iterator begin() const { return const_iterator(_start); }
 349     const_iterator cbegin() const { return const_iterator(_start); }
 350     iterator end() { return iterator(_finish); }
 351     const_iterator end() const { return const_iterator(_finish); }
 352     const_iterator cend() const { return const_iterator(_finish); }
 353     T& front() { return *begin(); }
 354     const T& front() const { return *begin(); }
 355     T& back() { return *(end() - 1); }
 356     const T& back() const { return *(end() - 1); }
 357   };
 358
 359   template<typename T>
 360   class list {
 361     struct __item {
 362       T data;
 363       __item *prev, *next;
 364     } *_start, *_finish;
 365
 366   public:
 367     typedef T value_type;
 368     typedef size_t size_type;
 369     typedef __list_iterator<__item, T *, T &> iterator;
 370     typedef __list_iterator<__item, const T *, const T &> const_iterator;
 371
 372     list() : _start(0), _finish(0) {}
 373     template <typename InputIterator>
 374     list(InputIterator first, InputIterator last);
 375     list(const list &other);
 376     list(list &&other);
 377     ~list();
 378
 379     list& operator=(const list &other);
 380     list& operator=(list &&other);
 381     list& operator=(std::initializer_list<T> ilist);
 382
 383     void assign(size_type count, const T &value);
 384     template <typename InputIterator >
 385     void assign(InputIterator first, InputIterator last);
 386     void assign(std::initializer_list<T> ilist);
 387
 388     void clear();
 389
 390     void push_back(const T &value);
 391     void push_back(T &&value);
 392     template<class... Args>
 393     void emplace_back(Args&&... args);
 394     void pop_back();
 395
 396     void push_front(const T &value);
 397     void push_front(T &&value);
 398     template<class... Args>
 399     void emplace_front(Args&&... args);
 400     void pop_front();
 401
 402     iterator insert(const_iterator position, const value_type &val);
 403     iterator insert(const_iterator position, size_type n,
 404                     const value_type &val);
 405     template <typename InputIterator>
 406     iterator insert(const_iterator position, InputIterator first,
 407                     InputIterator last);
 408     iterator insert(const_iterator position, value_type &&val);
 409     iterator insert(const_iterator position, initializer_list<value_type> il);
 410
 411     template <class... Args>
 412     iterator emplace(const_iterator position, Args&&... args);
 413
 414     iterator erase(const_iterator position);
 415     iterator erase(const_iterator first, const_iterator last);
 416
 417     iterator begin() { return iterator(_start); }
 418     const_iterator begin() const { return const_iterator(_start); }
 419     const_iterator cbegin() const { return const_iterator(_start); }
 420     iterator end() { return iterator(_finish); }
 421     const_iterator end() const { return const_iterator(_finish); }
 422     const_iterator cend() const { return const_iterator(_finish); }
 423
 424     T& front() { return *begin(); }
 425     const T& front() const { return *begin(); }
 426     T& back() { return *--end(); }
 427     const T& back() const { return *--end(); }
 428   };
 429
 430   template<typename T>
 431   class deque {
 432     T *_start;
 433     T *_finish;
 434     T *_end_of_storage;
 435
 436   public:
 437     typedef T value_type;
 438     typedef size_t size_type;
 439     typedef __deque_iterator<T, T *, T &> iterator;
 440     typedef __deque_iterator<T, const T *, const T &> const_iterator;
 441
 442     deque() : _start(0), _finish(0), _end_of_storage(0) {}
 443     template <typename InputIterator>
 444     deque(InputIterator first, InputIterator last);
 445     deque(const deque &other);
 446     deque(deque &&other);
 447     ~deque();
 448
 449     size_t size() const {
 450       return size_t(_finish - _start);
 451     }
 452
 453     deque& operator=(const deque &other);
 454     deque& operator=(deque &&other);
 455     deque& operator=(std::initializer_list<T> ilist);
 456
 457     void assign(size_type count, const T &value);
 458     template <typename InputIterator >
 459     void assign(InputIterator first, InputIterator last);
 460     void assign(std::initializer_list<T> ilist);
 461
 462     void clear();
 463
 464     void push_back(const T &value);
 465     void push_back(T &&value);
 466     template<class... Args>
 467     void emplace_back(Args&&... args);
 468     void pop_back();
 469
 470     void push_front(const T &value);
 471     void push_front(T &&value);
 472     template<class... Args>
 473     void emplace_front(Args&&... args);
 474     void pop_front();
 475
 476     iterator insert(const_iterator position, const value_type &val);
 477     iterator insert(const_iterator position, size_type n,
 478                     const value_type &val);
 479     template <typename InputIterator>
 480     iterator insert(const_iterator position, InputIterator first,
 481                     InputIterator last);
 482     iterator insert(const_iterator position, value_type &&val);
 483     iterator insert(const_iterator position, initializer_list<value_type> il);
 484
 485     template <class... Args>
 486     iterator emplace(const_iterator position, Args&&... args);
 487
 488     iterator erase(const_iterator position);
 489     iterator erase(const_iterator first, const_iterator last);
 490
 491     T &operator[](size_t n) {
 492       return _start[n];
 493     }
 494
 495     const T &operator[](size_t n) const {
 496       return _start[n];
 497     }
 498
 499     iterator begin() { return iterator(_start); }
 500     const_iterator begin() const { return const_iterator(_start); }
 501     const_iterator cbegin() const { return const_iterator(_start); }
 502     iterator end() { return iterator(_finish); }
 503     const_iterator end() const { return const_iterator(_finish); }
 504     const_iterator cend() const { return const_iterator(_finish); }
 505     T& front() { return *begin(); }
 506     const T& front() const { return *begin(); }
 507     T& back() { return *(end() - 1); }
 508     const T& back() const { return *(end() - 1); }
 509   };
 510
 511   template<typename T>
 512   class forward_list {
 513     struct __item {
 514       T data;
 515       __item *next;
 516     } *_start;
 517
 518   public:
 519     typedef T value_type;
 520     typedef size_t size_type;
 521     typedef __fwdl_iterator<__item, T *, T &> iterator;
 522     typedef __fwdl_iterator<__item, const T *, const T &> const_iterator;
 523
 524     forward_list() : _start(0) {}
 525     template <typename InputIterator>
 526     forward_list(InputIterator first, InputIterator last);
 527     forward_list(const forward_list &other);
 528     forward_list(forward_list &&other);
 529     ~forward_list();
 530
 531     forward_list& operator=(const forward_list &other);
 532     forward_list& operator=(forward_list &&other);
 533     forward_list& operator=(std::initializer_list<T> ilist);
 534
 535     void assign(size_type count, const T &value);
 536     template <typename InputIterator >
 537     void assign(InputIterator first, InputIterator last);
 538     void assign(std::initializer_list<T> ilist);
 539
 540     void clear();
 541
 542     void push_front(const T &value);
 543     void push_front(T &&value);
 544     template<class... Args>
 545     void emplace_front(Args&&... args);
 546     void pop_front();
 547
 548     iterator insert_after(const_iterator position, const value_type &val);
 549     iterator insert_after(const_iterator position, value_type &&val);
 550     iterator insert_after(const_iterator position, size_type n,
 551                           const value_type &val);
 552     template <typename InputIterator>
 553     iterator insert_after(const_iterator position, InputIterator first,
 554                           InputIterator last);
 555     iterator insert_after(const_iterator position,
 556                           initializer_list<value_type> il);
 557
 558     template <class... Args>
 559     iterator emplace_after(const_iterator position, Args&&... args);
 560
 561     iterator erase_after(const_iterator position);
 562     iterator erase_after(const_iterator first, const_iterator last);
 563
 564     iterator begin() { return iterator(_start); }
 565     const_iterator begin() const { return const_iterator(_start); }
 566     const_iterator cbegin() const { return const_iterator(_start); }
 567     iterator end() { return iterator(); }
 568     const_iterator end() const { return const_iterator(); }
 569     const_iterator cend() const { return const_iterator(); }
 570
 571     T& front() { return *begin(); }
 572     const T& front() const { return *begin(); }
 573   };
 574
 575   template <typename CharT>
 576   class basic_string {
 577     class Allocator {};
 578
 579   public:
 580     basic_string() : basic_string(Allocator()) {}
 581     explicit basic_string(const Allocator &alloc);
 582     basic_string(size_type count, CharT ch,
 583                  const Allocator &alloc = Allocator());
 584     basic_string(const basic_string &other,
 585                  size_type pos,
 586                  const Allocator &alloc = Allocator());
 587     basic_string(const basic_string &other,
 588                  size_type pos, size_type count,
 589                  const Allocator &alloc = Allocator());
 590     basic_string(const CharT *s, size_type count,
 591                  const Allocator &alloc = Allocator());
 592     basic_string(const CharT *s,
 593                  const Allocator &alloc = Allocator());
 594     template <class InputIt>
 595     basic_string(InputIt first, InputIt last,
 596                  const Allocator &alloc = Allocator());
 597     basic_string(const basic_string &other);
 598     basic_string(const basic_string &other,
 599                  const Allocator &alloc);
 600     basic_string(basic_string &&other);
 601     basic_string(basic_string &&other,
 602                  const Allocator &alloc);
 603     basic_string(std::initializer_list<CharT> ilist,
 604                  const Allocator &alloc = Allocator());
 605     template <class T>
 606     basic_string(const T &t, size_type pos, size_type n,
 607                  const Allocator &alloc = Allocator());
 608     // basic_string(std::nullptr_t) = delete;
 609
 610     ~basic_string();
 611     void clear();
 612
 613     basic_string &operator=(const basic_string &str);
 614     basic_string &operator+=(const basic_string &str);
 615
 616     const CharT *c_str() const;
 617     const CharT *data() const;
 618     CharT *data();
 619
 620     const char *begin() const;
 621     const char *end() const;
 622
 623     basic_string &append(size_type count, CharT ch);
 624     basic_string &assign(size_type count, CharT ch);
 625     basic_string &erase(size_type index, size_type count);
 626     basic_string &insert(size_type index, size_type count, CharT ch);
 627     basic_string &replace(size_type pos, size_type count, const basic_string &str);
 628     void pop_back();
 629     void push_back(CharT ch);
 630     void reserve(size_type new_cap);
 631     void resize(size_type count);
 632     void shrink_to_fit();
 633     void swap(basic_string &other);
 634   };
 635
 636   typedef basic_string<char> string;
 637   typedef basic_string<wchar_t> wstring;
 638 #if __cplusplus >= 201103L
 639   typedef basic_string<char16_t> u16string;
 640   typedef basic_string<char32_t> u32string;
 641 #endif
 642
 643   class exception {
 644   public:
 645     exception() throw();
 646     virtual ~exception() throw();
 647     virtual const char *what() const throw() {
 648       return 0;
 649     }
 650   };
 651
 652   class bad_alloc : public exception {
 653     public:
 654     bad_alloc() throw();
 655     bad_alloc(const bad_alloc&) throw();
 656     bad_alloc& operator=(const bad_alloc&) throw();
 657     virtual const char* what() const throw() {
 658       return 0;
 659     }
 660   };
 661
 662   struct nothrow_t {};
 663   extern const nothrow_t nothrow;
 664
 665   enum class align_val_t : size_t {};
 666
 667   // libc++'s implementation
 668   template <class _E>
 669   class initializer_list
 670   {
 671     const _E* __begin_;
 672     size_t    __size_;
 673
 674     initializer_list(const _E* __b, size_t __s)
 675       : __begin_(__b),
 676         __size_(__s)
 677     {}
 678
 679   public:
 680     typedef _E        value_type;
 681     typedef const _E& reference;
 682     typedef const _E& const_reference;
 683     typedef size_t    size_type;
 684
 685     typedef const _E* iterator;
 686     typedef const _E* const_iterator;
 687
 688     initializer_list() : __begin_(0), __size_(0) {}
 689
 690     size_t    size()  const {return __size_;}
 691     const _E* begin() const {return __begin_;}
 692     const _E* end()   const {return __begin_ + __size_;}
 693   };
 694
 695   template <bool, class _Tp = void> struct enable_if {};
 696   template <class _Tp> struct enable_if<true, _Tp> {typedef _Tp type;};
 697
 698   template <class _Tp, _Tp __v>
 699   struct integral_constant
 700   {
 701       static const _Tp      value = __v;
 702       typedef _Tp               value_type;
 703       typedef integral_constant type;
 704
 705      operator value_type() const {return value;}
 706
 707      value_type operator ()() const {return value;}
 708   };
 709
 710   template <class _Tp, _Tp __v>
 711   const _Tp integral_constant<_Tp, __v>::value;
 712
 713     template <class _Tp, class _Arg>
 714     struct is_trivially_assignable
 715       : integral_constant<bool, __is_trivially_assignable(_Tp, _Arg)>
 716     {
 717     };
 718
 719   typedef integral_constant<bool,true>  true_type;
 720   typedef integral_constant<bool,false> false_type;
 721
 722   template <class _Tp> struct is_const            : public false_type {};
 723   template <class _Tp> struct is_const<_Tp const> : public true_type {};
 724
 725   template <class _Tp> struct  is_reference        : public false_type {};
 726   template <class _Tp> struct  is_reference<_Tp&>  : public true_type {};
 727
 728   template <class _Tp, class _Up> struct  is_same           : public false_type {};
 729   template <class _Tp>            struct  is_same<_Tp, _Tp> : public true_type {};
 730
 731   #if __cplusplus >= 201703L
 732   template< class T, class U >
 733   inline constexpr bool is_same_v = is_same<T, U>::value;
 734   #endif
 735
 736   template <class _Tp, bool = is_const<_Tp>::value || is_reference<_Tp>::value    >
 737   struct __add_const             {typedef _Tp type;};
 738
 739   template <class _Tp>
 740   struct __add_const<_Tp, false> {typedef const _Tp type;};
 741
 742   template <class _Tp> struct add_const {typedef typename __add_const<_Tp>::type type;};
 743
 744   template <class _Tp> struct  remove_const            {typedef _Tp type;};
 745   template <class _Tp> struct  remove_const<const _Tp> {typedef _Tp type;};
 746
 747   template< class T >
 748   using remove_const_t = typename remove_const<T>::type;
 749
 750   template <class _Tp> struct  add_lvalue_reference    {typedef _Tp& type;};
 751
 752   template <class _Tp> struct is_trivially_copy_assignable
 753       : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
 754             typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};
 755
 756     template<class InputIter, class OutputIter>
 757     OutputIter __copy(InputIter II, InputIter IE, OutputIter OI) {
 758       while (II != IE)
 759         *OI++ = *II++; // #system_header_simulator_cxx_std_copy_impl_loop
 760
 761       return OI;
 762     }
 763
 764   template <class _Tp, class _Up>
 765   inline
 766   typename enable_if
 767   <
 768       is_same<typename remove_const<_Tp>::type, _Up>::value &&
 769       is_trivially_copy_assignable<_Up>::value,
 770       _Up*
 771   >::type __copy(_Tp* __first, _Tp* __last, _Up* __result) {
 772       size_t __n = __last - __first;
 773
 774       if (__n > 0)
 775         memmove(__result, __first, __n * sizeof(_Up));
 776
 777       return __result + __n;
 778     }
 779
 780   template<class InputIter, class OutputIter>
 781   OutputIter copy(InputIter II, InputIter IE, OutputIter OI) {
 782     return __copy(II, IE, OI);
 783   }
 784
 785   template <class _BidirectionalIterator, class _OutputIterator>
 786   inline
 787   _OutputIterator
 788   __copy_backward(_BidirectionalIterator __first, _BidirectionalIterator __last,
 789                   _OutputIterator __result)
 790   {
 791       while (__first != __last)
 792           *--__result = *--__last;
 793       return __result;
 794   }
 795
 796   template <class _Tp, class _Up>
 797   inline
 798   typename enable_if
 799   <
 800       is_same<typename remove_const<_Tp>::type, _Up>::value &&
 801       is_trivially_copy_assignable<_Up>::value,
 802       _Up*
 803   >::type __copy_backward(_Tp* __first, _Tp* __last, _Up* __result) {
 804       size_t __n = __last - __first;
 805
 806     if (__n > 0)
 807     {
 808         __result -= __n;
 809         memmove(__result, __first, __n * sizeof(_Up));
 810     }
 811     return __result;
 812   }
 813
 814   template< bool B, class T = void >
 815   using enable_if_t = typename enable_if<B,T>::type;
 816
 817   template<class InputIter, class OutputIter>
 818   OutputIter copy_backward(InputIter II, InputIter IE, OutputIter OI) {
 819     return __copy_backward(II, IE, OI);
 820   }
 821 }
 822
 823 template <class BidirectionalIterator, class Distance>
 824 void __advance(BidirectionalIterator& it, Distance n,
 825                std::bidirectional_iterator_tag)
 826 #if !defined(STD_ADVANCE_INLINE_LEVEL) || STD_ADVANCE_INLINE_LEVEL > 2
 827 {
 828   if (n >= 0) while(n-- > 0) ++it; else while (n++<0) --it;
 829 }
 830 #else
 831     ;
 832 #endif
 833
 834 template <class RandomAccessIterator, class Distance>
 835 void __advance(RandomAccessIterator& it, Distance n,
 836                std::random_access_iterator_tag)
 837 #if !defined(STD_ADVANCE_INLINE_LEVEL) || STD_ADVANCE_INLINE_LEVEL > 2
 838 {
 839   it += n;
 840 }
 841 #else
 842     ;
 843 #endif
 844
 845 namespace std {
 846
 847 template <class InputIterator, class Distance>
 848 void advance(InputIterator& it, Distance n)
 849 #if !defined(STD_ADVANCE_INLINE_LEVEL) || STD_ADVANCE_INLINE_LEVEL > 1
 850 {
 851   __advance(it, n, typename InputIterator::iterator_category());
 852 }
 853 #else
 854     ;
 855 #endif
 856
 857 template <class BidirectionalIterator>
 858 BidirectionalIterator
 859 prev(BidirectionalIterator it,
 860      typename iterator_traits<BidirectionalIterator>::difference_type n =
 861          1)
 862 #if !defined(STD_ADVANCE_INLINE_LEVEL) || STD_ADVANCE_INLINE_LEVEL > 0
 863 {
 864   advance(it, -n);
 865   return it;
 866 }
 867 #else
 868     ;
 869 #endif
 870
 871 template <class ForwardIterator>
 872 ForwardIterator
 873 next(ForwardIterator it,
 874      typename iterator_traits<ForwardIterator>::difference_type n =
 875          1)
 876 #if !defined(STD_ADVANCE_INLINE_LEVEL) || STD_ADVANCE_INLINE_LEVEL > 0
 877 {
 878   advance(it, n);
 879   return it;
 880 }
 881 #else
 882     ;
 883 #endif
 884
 885   template <class InputIt, class T>
 886   InputIt find(InputIt first, InputIt last, const T& value);
 887
 888   template <class ExecutionPolicy, class ForwardIt, class T>
 889   ForwardIt find(ExecutionPolicy&& policy, ForwardIt first, ForwardIt last,
 890                  const T& value);
 891
 892   template <class InputIt, class UnaryPredicate>
 893   InputIt find_if (InputIt first, InputIt last, UnaryPredicate p);
 894
 895   template <class ExecutionPolicy, class ForwardIt, class UnaryPredicate>
 896   ForwardIt find_if (ExecutionPolicy&& policy, ForwardIt first, ForwardIt last,
 897                      UnaryPredicate p);
 898
 899   template <class InputIt, class UnaryPredicate>
 900   InputIt find_if_not (InputIt first, InputIt last, UnaryPredicate q);
 901
 902   template <class ExecutionPolicy, class ForwardIt, class UnaryPredicate>
 903   ForwardIt find_if_not (ExecutionPolicy&& policy, ForwardIt first,
 904                          ForwardIt last, UnaryPredicate q);
 905
 906   template <class InputIt, class ForwardIt>
 907   InputIt find_first_of(InputIt first, InputIt last,
 908                          ForwardIt s_first, ForwardIt s_last);
 909
 910   template <class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
 911   ForwardIt1 find_first_of (ExecutionPolicy&& policy,
 912                             ForwardIt1 first, ForwardIt1 last,
 913                             ForwardIt2 s_first, ForwardIt2 s_last);
 914
 915   template <class InputIt, class ForwardIt, class BinaryPredicate>
 916   InputIt find_first_of (InputIt first, InputIt last,
 917                          ForwardIt s_first, ForwardIt s_last,
 918                          BinaryPredicate p );
 919
 920   template <class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
 921             class BinaryPredicate>
 922   ForwardIt1 find_first_of (ExecutionPolicy&& policy,
 923                             ForwardIt1 first, ForwardIt1 last,
 924                             ForwardIt2 s_first, ForwardIt2 s_last,
 925                             BinaryPredicate p );
 926
 927   template <class InputIt, class ForwardIt>
 928   InputIt find_end(InputIt first, InputIt last,
 929                    ForwardIt s_first, ForwardIt s_last);
 930
 931   template <class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
 932   ForwardIt1 find_end (ExecutionPolicy&& policy,
 933                        ForwardIt1 first, ForwardIt1 last,
 934                        ForwardIt2 s_first, ForwardIt2 s_last);
 935
 936   template <class InputIt, class ForwardIt, class BinaryPredicate>
 937   InputIt find_end (InputIt first, InputIt last,
 938                     ForwardIt s_first, ForwardIt s_last,
 939                     BinaryPredicate p );
 940
 941   template <class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
 942             class BinaryPredicate>
 943   ForwardIt1 find_end (ExecutionPolicy&& policy,
 944                        ForwardIt1 first, ForwardIt1 last,
 945                        ForwardIt2 s_first, ForwardIt2 s_last,
 946                        BinaryPredicate p );
 947
 948   template <class ForwardIt, class T>
 949   ForwardIt lower_bound (ForwardIt first, ForwardIt last, const T& value);
 950
 951   template <class ForwardIt, class T, class Compare>
 952   ForwardIt lower_bound (ForwardIt first, ForwardIt last, const T& value,
 953                          Compare comp);
 954
 955   template <class ForwardIt, class T>
 956   ForwardIt upper_bound (ForwardIt first, ForwardIt last, const T& value);
 957
 958   template <class ForwardIt, class T, class Compare>
 959   ForwardIt upper_bound (ForwardIt first, ForwardIt last, const T& value,
 960                          Compare comp);
 961
 962   template <class ForwardIt1, class ForwardIt2>
 963   ForwardIt1 search (ForwardIt1 first, ForwardIt1 last,
 964                      ForwardIt2 s_first, ForwardIt2 s_last);
 965
 966   template <class ExecutionPolicy, class ForwardIt1, class ForwardIt2>
 967   ForwardIt1 search (ExecutionPolicy&& policy,
 968                      ForwardIt1 first, ForwardIt1 last,
 969                      ForwardIt2 s_first, ForwardIt2 s_last);
 970
 971   template <class ForwardIt1, class ForwardIt2, class BinaryPredicate>
 972   ForwardIt1 search (ForwardIt1 first, ForwardIt1 last,
 973                      ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p);
 974
 975   template <class ExecutionPolicy, class ForwardIt1, class ForwardIt2,
 976             class BinaryPredicate >
 977   ForwardIt1 search (ExecutionPolicy&& policy,
 978                      ForwardIt1 first, ForwardIt1 last,
 979                      ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p);
 980
 981   template <class ForwardIt, class Searcher>
 982   ForwardIt search (ForwardIt first, ForwardIt last, const Searcher& searcher);
 983
 984   template <class ForwardIt, class Size, class T>
 985   ForwardIt search_n (ForwardIt first, ForwardIt last, Size count,
 986                       const T& value);
 987
 988   template <class ExecutionPolicy, class ForwardIt, class Size, class T>
 989   ForwardIt search_n (ExecutionPolicy&& policy, ForwardIt first, ForwardIt last,
 990                       Size count, const T& value);
 991
 992   template <class ForwardIt, class Size, class T, class BinaryPredicate>
 993   ForwardIt search_n (ForwardIt first, ForwardIt last, Size count,
 994                       const T& value, BinaryPredicate p);
 995
 996   template <class ExecutionPolicy, class ForwardIt, class Size, class T,
 997             class BinaryPredicate>
 998   ForwardIt search_n (ExecutionPolicy&& policy, ForwardIt first, ForwardIt last,
 999                       Size count, const T& value, BinaryPredicate p);
1000
1001   template <class InputIterator, class OutputIterator>
1002   OutputIterator copy(InputIterator first, InputIterator last,
1003                       OutputIterator result);
1004
1005 }
1006
1007 #if __cplusplus >= 201103L
1008 namespace std {
1009 template <typename T> // TODO: Implement the stub for deleter.
1010 class unique_ptr {
1011 public:
1012   unique_ptr() noexcept {}
1013   unique_ptr(T *) noexcept {}
1014   unique_ptr(const unique_ptr &) noexcept = delete;
1015   unique_ptr(unique_ptr &&) noexcept;
1016
1017   T *get() const noexcept;
1018   T *release() noexcept;
1019   void reset(T *p = nullptr) noexcept;
1020   void swap(unique_ptr<T> &p) noexcept;
1021
1022   typename std::add_lvalue_reference<T>::type operator*() const;
1023   T *operator->() const noexcept;
1024   operator bool() const noexcept;
1025   unique_ptr<T> &operator=(unique_ptr<T> &&p) noexcept;
1026   unique_ptr<T> &operator=(nullptr_t) noexcept;
1027 };
1028
1029 // TODO :: Once the deleter parameter is added update with additional template parameter.
1030 template <typename T>
1031 void swap(unique_ptr<T> &x, unique_ptr<T> &y) noexcept {
1032   x.swap(y);
1033 }
1034
1035 template <typename T1, typename T2>
1036 bool operator==(const unique_ptr<T1> &x, const unique_ptr<T2> &y);
1037
1038 template <typename T1, typename T2>
1039 bool operator!=(const unique_ptr<T1> &x, const unique_ptr<T2> &y);
1040
1041 template <typename T1, typename T2>
1042 bool operator<(const unique_ptr<T1> &x, const unique_ptr<T2> &y);
1043
1044 template <typename T1, typename T2>
1045 bool operator>(const unique_ptr<T1> &x, const unique_ptr<T2> &y);
1046
1047 template <typename T1, typename T2>
1048 bool operator<=(const unique_ptr<T1> &x, const unique_ptr<T2> &y);
1049
1050 template <typename T1, typename T2>
1051 bool operator>=(const unique_ptr<T1> &x, const unique_ptr<T2> &y);
1052
1053 template <typename T>
1054 bool operator==(const unique_ptr<T> &x, nullptr_t y);
1055
1056 template <typename T>
1057 bool operator!=(const unique_ptr<T> &x, nullptr_t y);
1058
1059 template <typename T>
1060 bool operator<(const unique_ptr<T> &x, nullptr_t y);
1061
1062 template <typename T>
1063 bool operator>(const unique_ptr<T> &x, nullptr_t y);
1064
1065 template <typename T>
1066 bool operator<=(const unique_ptr<T> &x, nullptr_t y);
1067
1068 template <typename T>
1069 bool operator>=(const unique_ptr<T> &x, nullptr_t y);
1070
1071 template <typename T>
1072 bool operator==(nullptr_t x, const unique_ptr<T> &y);
1073
1074 template <typename T>
1075 bool operator!=(nullptr_t x, const unique_ptr<T> &y);
1076
1077 template <typename T>
1078 bool operator>(nullptr_t x, const unique_ptr<T> &y);
1079
1080 template <typename T>
1081 bool operator<(nullptr_t x, const unique_ptr<T> &y);
1082
1083 template <typename T>
1084 bool operator>=(nullptr_t x, const unique_ptr<T> &y);
1085
1086 template <typename T>
1087 bool operator<=(nullptr_t x, const unique_ptr<T> &y);
1088
1089 template <class T, class... Args>
1090 unique_ptr<T> make_unique(Args &&...args);
1091
1092 #if __cplusplus >= 202002L
1093
1094 template <class T>
1095 unique_ptr<T> make_unique_for_overwrite();
1096
1097 #endif
1098
1099 } // namespace std
1100 #endif
1101
1102 namespace std {
1103 template <class CharT>
1104 class basic_ostream;
1105
1106 using ostream = basic_ostream<char>;
1107
1108 extern std::ostream cout;
1109
1110 ostream &operator<<(ostream &, const string &);
1111
1112 #if __cplusplus >= 202002L
1113 template <class T>
1114 ostream &operator<<(ostream &, const std::unique_ptr<T> &);
1115 #endif
1116
1117 template <class CharT>
1118 class basic_istream;
1119
1120 using istream = basic_istream<char>;
1121
1122 extern std::istream cin;
1123
1124 istream &getline(istream &, string &, char);
1125 istream &getline(istream &, string &);
1126 } // namespace std
1127
1128 namespace std {
1129   void *malloc(size_t);
1130   void free(void *);
1131 } // namespace std
1132
1133 #ifdef TEST_INLINABLE_ALLOCATORS
1134 void* operator new(std::size_t size, const std::nothrow_t&) throw() { return std::malloc(size); }
1135 void* operator new[](std::size_t size, const std::nothrow_t&) throw() { return std::malloc(size); }
1136 void operator delete(void* ptr, const std::nothrow_t&) throw() { std::free(ptr); }
1137 void operator delete[](void* ptr, const std::nothrow_t&) throw() { std::free(ptr); }
1138 #else
1139 // C++20 standard draft 17.6.1, from "Header <new> synopsis", but with throw()
1140 // instead of noexcept:
1141
1142 void *operator new(std::size_t size);
1143 void *operator new(std::size_t size, std::align_val_t alignment);
1144 void *operator new(std::size_t size, const std::nothrow_t &) throw();
1145 void *operator new(std::size_t size, std::align_val_t alignment,
1146                    const std::nothrow_t &) throw();
1147 void operator delete(void *ptr) throw();
1148 void operator delete(void *ptr, std::size_t size) throw();
1149 void operator delete(void *ptr, std::align_val_t alignment) throw();
1150 void operator delete(void *ptr, std::size_t size, std::align_val_t alignment) throw();
1151 void operator delete(void *ptr, const std::nothrow_t &)throw();
1152 void operator delete(void *ptr, std::align_val_t alignment,
1153                      const std::nothrow_t &)throw();
1154 void *operator new[](std::size_t size);
1155 void *operator new[](std::size_t size, std::align_val_t alignment);
1156 void *operator new[](std::size_t size, const std::nothrow_t &) throw();
1157 void *operator new[](std::size_t size, std::align_val_t alignment,
1158                      const std::nothrow_t &) throw();
1159 void operator delete[](void *ptr) throw();
1160 void operator delete[](void *ptr, std::size_t size) throw();
1161 void operator delete[](void *ptr, std::align_val_t alignment) throw();
1162 void operator delete[](void *ptr, std::size_t size, std::align_val_t alignment) throw();
1163 void operator delete[](void *ptr, const std::nothrow_t &) throw();
1164 void operator delete[](void *ptr, std::align_val_t alignment,
1165                        const std::nothrow_t &) throw();
1166 #endif
1167
1168 void* operator new (std::size_t size, void* ptr) throw() { return ptr; };
1169 void* operator new[] (std::size_t size, void* ptr) throw() { return ptr; };
1170 void operator delete (void* ptr, void*) throw() {};
1171 void operator delete[] (void* ptr, void*) throw() {};
1172
1173 namespace __cxxabiv1 {
1174 extern "C" {
1175 extern char *__cxa_demangle(const char *mangled_name,
1176                             char *output_buffer,
1177                             size_t *length,
1178                             int *status);
1179 }}
1180 namespace abi = __cxxabiv1;
1181
1182 namespace std {
1183   template<class ForwardIt>
1184   bool is_sorted(ForwardIt first, ForwardIt last);
1185
1186   template <class RandomIt>
1187   void nth_element(RandomIt first, RandomIt nth, RandomIt last);
1188
1189   template<class RandomIt>
1190   void partial_sort(RandomIt first, RandomIt middle, RandomIt last);
1191
1192   template<class RandomIt>
1193   void sort (RandomIt first, RandomIt last);
1194
1195   template<class RandomIt>
1196   void stable_sort(RandomIt first, RandomIt last);
1197
1198   template<class BidirIt, class UnaryPredicate>
1199   BidirIt partition(BidirIt first, BidirIt last, UnaryPredicate p);
1200
1201   template<class BidirIt, class UnaryPredicate>
1202   BidirIt stable_partition(BidirIt first, BidirIt last, UnaryPredicate p);
1203 }
1204
1205 namespace std {
1206
1207 template< class T = void >
1208 struct less;
1209
1210 template< class T >
1211 struct allocator;
1212
1213 template< class Key >
1214 struct hash;
1215
1216 template<
1217   class Key,
1218   class Compare = std::less<Key>,
1219   class Alloc = std::allocator<Key>
1220 > class set {
1221   public:
1222     set(initializer_list<Key> __list) {}
1223
1224     class iterator {
1225     public:
1226       iterator(Key *key): ptr(key) {}
1227       iterator& operator++() { ++ptr; return *this; }
1228       bool operator!=(const iterator &other) const { return ptr != other.ptr; }
1229       const Key &operator*() const { return *ptr; }
1230     private:
1231       Key *ptr;
1232     };
1233
1234   public:
1235     Key *val;
1236     iterator begin() const { return iterator(val); }
1237     iterator end() const { return iterator(val + 1); }
1238 };
1239
1240 template<
1241   class Key,
1242   class Hash = std::hash<Key>,
1243   class Compare = std::less<Key>,
1244   class Alloc = std::allocator<Key>
1245 > class unordered_set {
1246   public:
1247     unordered_set(initializer_list<Key> __list) {}
1248
1249     class iterator {
1250     public:
1251       iterator(Key *key): ptr(key) {}
1252       iterator& operator++() { ++ptr; return *this; }
1253       bool operator!=(const iterator &other) const { return ptr != other.ptr; }
1254       const Key &operator*() const { return *ptr; }
1255     private:
1256       Key *ptr;
1257     };
1258
1259   public:
1260     Key *val;
1261     iterator begin() const { return iterator(val); }
1262     iterator end() const { return iterator(val + 1); }
1263 };
1264
1265 template <typename T>
1266 class atomic {
1267 public:
1268   T operator++();
1269   T operator--();
1270 };
1271
1272 namespace execution {
1273 class sequenced_policy {};
1274 }
1275
1276 template <class T = void> struct equal_to {};
1277
1278 template <class ForwardIt, class BinaryPredicate = std::equal_to<> >
1279 class default_searcher {
1280 public:
1281   default_searcher (ForwardIt pat_first,
1282                     ForwardIt pat_last,
1283                     BinaryPredicate pred = BinaryPredicate());
1284   template <class ForwardIt2>
1285   std::pair <ForwardIt2, ForwardIt2>
1286   operator()( ForwardIt2 first, ForwardIt2 last ) const;
1287 };
1288
1289 template <typename> class packaged_task;
1290 template <typename Ret, typename... Args> class packaged_task<Ret(Args...)> {
1291   // TODO: Add some actual implementation.
1292 };
1293
1294   #if __cplusplus >= 201703L
1295
1296   namespace detail
1297   {
1298     template<class T>
1299     struct type_identity { using type = T; }; // or use std::type_identity (since C++20)
1300
1301     template<class T>
1302     auto try_add_pointer(int) -> type_identity<typename std::remove_reference<T>::type*>;
1303     template<class T>
1304     auto try_add_pointer(...) -> type_identity<T>;
1305   } // namespace detail
1306
1307   template<class T>
1308   struct add_pointer : decltype(detail::try_add_pointer<T>(0)) {};
1309
1310   template< class T >
1311   using add_pointer_t = typename add_pointer<T>::type;
1312
1313   template<class T> struct remove_cv { typedef T type; };
1314   template<class T> struct remove_cv<const T> { typedef T type; };
1315   template<class T> struct remove_cv<volatile T> { typedef T type; };
1316   template<class T> struct remove_cv<const volatile T> { typedef T type; };
1317
1318   template< class T >
1319   using remove_cv_t = typename remove_cv<T>::type;
1320
1321   // This decay does not behave exactly like std::decay, but this is enough
1322   // for testing the std::variant checker
1323   template<class T>
1324   struct decay{typedef remove_cv_t<remove_reference_t<T>> type;};
1325   template<class T>
1326   using decay_t = typename decay<T>::type;
1327
1328   // variant
1329   template <class... Types> class variant;
1330   // variant helper classes
1331   template <class T> struct variant_size;
1332   template <class T> struct variant_size<const T>;
1333   template <class T> struct variant_size<volatile T>;
1334   template <class T> struct variant_size<const volatile T>;
1335   template <class T> inline constexpr size_t variant_size_v = variant_size<T>::value;
1336   template <class... Types>
1337   struct variant_size<variant<Types...>>;
1338   template <size_t I, class T> struct variant_alternative;
1339   template <size_t I, class T> struct variant_alternative<I, const T>;
1340   template <size_t I, class T> struct variant_alternative<I, volatile T>;
1341   template <size_t I, class T> struct variant_alternative<I, const volatile T>;
1342   template <size_t I, class T>
1343   using variant_alternative_t = typename variant_alternative<I, T>::type;
1344   template <size_t I, class... Types>
1345   struct variant_alternative<I, variant<Types...>>;
1346   inline constexpr size_t variant_npos = -1;
1347   template <size_t I, class... Types>
1348   constexpr variant_alternative_t<I, variant<Types...>>&
1349     get(variant<Types...>&);
1350   template <size_t I, class... Types>
1351   constexpr variant_alternative_t<I, variant<Types...>>&&
1352     get(variant<Types...>&&);
1353   template <size_t I, class... Types>
1354   constexpr const variant_alternative_t<I, variant<Types...>>&
1355     get(const variant<Types...>&);
1356   template <size_t I, class... Types>
1357   constexpr const variant_alternative_t<I, variant<Types...>>&&
1358     get(const variant<Types...>&&);
1359   template <class T, class... Types>
1360   constexpr T& get(variant<Types...>&);
1361   template <class T, class... Types>
1362   constexpr T&& get(variant<Types...>&&);
1363   template <class T, class... Types>
1364   constexpr const T& get(const variant<Types...>&);
1365   template <class T, class... Types>
1366   constexpr const T&& get(const variant<Types...>&&);
1367   template <size_t I, class... Types>
1368   constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
1369     get_if(variant<Types...>*) noexcept;
1370   template <size_t I, class... Types>
1371   constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
1372     get_if(const variant<Types...>*) noexcept;
1373   template <class T, class... Types>
1374   constexpr add_pointer_t<T> get_if(variant<Types...>*) noexcept;
1375   template <class T, class... Types>
1376   constexpr add_pointer_t<const T> get_if(const variant<Types...>*) noexcept;
1377
1378   template <class... Types>
1379   class variant {
1380   public:
1381     // constructors
1382     constexpr variant()= default ;
1383     constexpr variant(const variant&);
1384     constexpr variant(variant&&);
1385     template<typename T,
1386             typename = std::enable_if_t<!is_same_v<std::variant<Types...>, decay_t<T>>>>
1387           constexpr variant(T&&);
1388     // assignment
1389     variant& operator=(const variant&);
1390     variant& operator=(variant&&) ;
1391     template<typename T,
1392             typename = std::enable_if_t<!is_same_v<std::variant<Types...>, decay_t<T>>>>
1393     variant& operator=(T&&);
1394   };
1395   #endif
1396
1397 } // namespace std