text: // Like the compiler, the static analyzer treats some functions differently if
  // they come from a system header -- for example, it is assumed that system
  // functions do not arbitrarily free() their parameters, and that some bugs
  // found in system headers cannot be fixed by the user and should be
  // suppressed.
  #pragma clang system_header
  
  typedef unsigned char uint8_t;
  
  namespace std {
    template <class T1, class T2>
    struct pair {
      T1 first;
      T2 second;
      
      pair() : first(), second() {}
      pair(const T1 &a, const T2 &b) : first(a), second(b) {}
      
      template<class U1, class U2>
      pair(const pair<U1, U2> &other) : first(other.first), second(other.second) {}
    };
    
    typedef __typeof__(sizeof(int)) size_t;
    
    template<typename T>
    class vector {
      T *_start;
      T *_finish;
      T *_end_of_storage;
    public:
      vector() : _start(0), _finish(0), _end_of_storage(0) {}
      ~vector();
      
      size_t size() const {
        return size_t(_finish - _start);
      }
      
      void push_back();
      T pop_back();
  
      T &operator[](size_t n) {
        return _start[n];
      }
      
      const T &operator[](size_t n) const {
        return _start[n];
      }
      
      T *begin() { return _start; }
      const T *begin() const { return _start; }
  
      T *end() { return _finish; }
      const T *end() const { return _finish; }
    };
    
    class exception {
    public:
      exception() throw();
      virtual ~exception() throw();
      virtual const char *what() const throw() {
        return 0;
      }
    };
  
    class bad_alloc : public exception {
      public:
      bad_alloc() throw();
      bad_alloc(const bad_alloc&) throw();
      bad_alloc& operator=(const bad_alloc&) throw();
      virtual const char* what() const throw() {
        return 0;
      }
    };
  
    struct nothrow_t {};
  
    extern const nothrow_t nothrow;
  
    // libc++'s implementation
    template <class _E>
    class initializer_list
    {
      const _E* __begin_;
      size_t    __size_;
  
      initializer_list(const _E* __b, size_t __s)
        : __begin_(__b),
          __size_(__s)
      {}
  
    public:
      typedef _E        value_type;
      typedef const _E& reference;
      typedef const _E& const_reference;
      typedef size_t    size_type;
  
      typedef const _E* iterator;
      typedef const _E* const_iterator;
  
      initializer_list() : __begin_(0), __size_(0) {}
  
      size_t    size()  const {return __size_;}
      const _E* begin() const {return __begin_;}
      const _E* end()   const {return __begin_ + __size_;}
    };
  
    template<class InputIter, class OutputIter>
    OutputIter copy(InputIter II, InputIter IE, OutputIter OI) {
      while (II != IE)
        *OI++ = *II++;
      return OI;
    }
  
    struct input_iterator_tag { };
    struct output_iterator_tag { };
    struct forward_iterator_tag : public input_iterator_tag { };
    struct bidirectional_iterator_tag : public forward_iterator_tag { };
    struct random_access_iterator_tag : public bidirectional_iterator_tag { };
  
    template <class _Tp>
    class allocator {
    public:
      void deallocate(void *p) {
        ::delete p;
      }
    };
  
    template <class _Alloc>
    class allocator_traits {
    public:
      static void deallocate(void *p) {
        _Alloc().deallocate(p);
      }
    };
  
    template <class _Tp, class _Alloc>
    class __list_imp
    {};
  
    template <class _Tp, class _Alloc = allocator<_Tp> >
    class list
    : private __list_imp<_Tp, _Alloc>
    {
    public:
      void pop_front() {
        // Fake use-after-free.
        // No warning is expected as we are suppressing warning coming
        // out of std::list.
        int z = 0;
        z = 5/z;
      }
      bool empty() const;
    };
  
    // basic_string
    template<class _CharT, class _Alloc = allocator<_CharT> >
    class __attribute__ ((__type_visibility__("default"))) basic_string {
      bool isLong;
      union {
        _CharT localStorage[4];
        _CharT *externalStorage;
  
        void assignExternal(_CharT *newExternal) {
          externalStorage = newExternal;
        }
      } storage;
  
      typedef allocator_traits<_Alloc> __alloc_traits;
  
    public:
      basic_string();
  
      void push_back(int c) {
        // Fake error trigger.
        // No warning is expected as we are suppressing warning coming
        // out of std::basic_string.
        int z = 0;
        z = 5/z;
      }
  
      _CharT *getBuffer() {
        return isLong ? storage.externalStorage : storage.localStorage;
      }
  
      basic_string &operator +=(int c) {
        // Fake deallocate stack-based storage.
        // No warning is expected as we are suppressing warnings within
        // std::basic_string.
        __alloc_traits::deallocate(getBuffer());
      }
  
      basic_string &operator =(const basic_string &other) {
        // Fake deallocate stack-based storage, then use the variable in the
        // same union.
        // No warning is expected as we are suppressing warnings within
        // std::basic_string.
        __alloc_traits::deallocate(getBuffer());
        storage.assignExternal(new _CharT[4]);
      }
    };
  }
  
  void* operator new(std::size_t, const std::nothrow_t&) throw();
  void* operator new[](std::size_t, const std::nothrow_t&) throw();
  void operator delete(void*, const std::nothrow_t&) throw();
  void operator delete[](void*, const std::nothrow_t&) throw();
  
  void* operator new (std::size_t size, void* ptr) throw() { return ptr; };
  void* operator new[] (std::size_t size, void* ptr) throw() { return ptr; };
  void operator delete (void* ptr, void*) throw() {};
  void operator delete[] (void* ptr, void*) throw() {};
  