/* { dg-do compile } */
/* { dg-require-effective-target c++11 } */
/* { dg-options "-O3 -fnon-call-exceptions -ftracer -march=k8 -Wno-return-type" } */


template <int __v> struct integral_constant {

  static constexpr int value = __v;

};

template <bool __v> using __bool_constant = integral_constant<__v>;

template <typename _Tp, typename _Up>

struct is_same : integral_constant<true> {};

template <bool, typename _Tp> using __enable_if_t = _Tp;

void *operator new(__SIZE_TYPE__, void *__p) { return __p; }

template <typename _Iterator, typename> class __normal_iterator {

  _Iterator _M_current;



public:

  __normal_iterator(_Iterator) {}

  void operator++() { ++_M_current; }

  _Iterator base() { return _M_current; }

};

template <typename _IteratorL, typename _IteratorR, typename _Container>

bool operator!=(__normal_iterator<_IteratorL, _Container> __lhs,

  __normal_iterator<_IteratorR, _Container> __rhs) {

  return __lhs.base() != __rhs.base();

}

template <typename _Tp> void construct_at(_Tp *__location) noexcept {

  new (__location) _Tp;

}

template <typename _Tp> void _Construct(_Tp __p) { construct_at(__p); }

struct _Any_data {

  template <typename _Tp> _Tp _M_access();

};

enum _Manager_operation {};

template <typename> class function;

class _Function_base {

public:

  template <typename _Functor> class _Base_manager {

public:

    static bool _M_manager(_Any_data, _Any_data __source, _Manager_operation) {

      _Functor(*__source._M_access<_Functor *>());

      return true;

    }

  };

  typedef bool (*_Manager_type)(_Any_data &, const _Any_data &,

    _Manager_operation);

  _Manager_type _M_manager;

};

template <typename, typename> class _Function_handler;

template <typename _Res, typename _Functor, typename... _ArgTypes>

class _Function_handler<_Res(_ArgTypes...), _Functor> : _Function_base {

public:

  static bool _M_manager(_Any_data &__dest, const _Any_data &__source,

    _Manager_operation __op) {

    _Base_manager<_Functor>::_M_manager(__dest, __source, __op);

  }

};

template <typename _Res, typename... _ArgTypes>

class function<_Res(_ArgTypes...)> : _Function_base {

  template <typename, typename _Tp> using _Requires = _Tp;



public:

  template <typename _Functor,

            typename = _Requires<__bool_constant<!bool()>, void>,

            typename = _Requires<_Functor, void>>

  function(_Functor);

};

template <typename _Res, typename... _ArgTypes>

template <typename _Functor, typename, typename>

function<_Res(_ArgTypes...)>::function(_Functor) {

  _M_manager = _Function_handler<_Res(), _Functor>::_M_manager;

}

template <typename _Tp> class new_allocator {

public:

  _Tp *allocate(long) { return static_cast<_Tp *>(operator new(sizeof(_Tp))); }

};

namespace std {

  template <typename> struct allocator_traits;

  template <typename _Tp> struct allocator_traits<new_allocator<_Tp>> {

    using allocator_type = new_allocator<_Tp>;

    using pointer = _Tp *;

    using const_pointer = _Tp *;

    using size_type = long;

    template <typename _Up> using rebind_alloc = new_allocator<_Up>;

    static pointer allocate(allocator_type __a, size_type __n) {

      return __a.allocate(__n);

    }

    static void deallocate(allocator_type, pointer, size_type);

  };

}

template <typename _Alloc>

struct __alloc_traits : std::allocator_traits<_Alloc> {

  template <typename _Tp> struct rebind {

    typedef typename std::allocator_traits<_Alloc>::template rebind_alloc<_Tp> other;

  };

};

namespace std {

  struct __uninitialized_copy {

    template <typename _InputIterator, typename _ForwardIterator>

    static _ForwardIterator __uninit_copy(_InputIterator __first,

      _InputIterator __last,

      _ForwardIterator __result) {

      for (; __first != __last; ++__first, ++__result)

        _Construct(__result);

      return __result;

    }

  };

  template <typename _InputIterator, typename _ForwardIterator>

  _ForwardIterator uninitialized_copy(_InputIterator __first,

    _InputIterator __last,

    _ForwardIterator __result) {

    return __uninitialized_copy::__uninit_copy(__first, __last, __result);

  }

  template <typename _InputIterator, typename _ForwardIterator, typename _Tp>

  _ForwardIterator __uninitialized_copy_a(_InputIterator __first,

    _InputIterator __last,

    _ForwardIterator __result, _Tp) {

    return uninitialized_copy(__first, __last, __result);

  }

  template <typename _Tp, typename _Alloc> struct _Vector_base {

    typedef typename __alloc_traits<_Alloc>::template rebind<_Tp>::other _Tp_alloc_type;

    typedef typename __alloc_traits<_Tp_alloc_type>::pointer pointer;

    struct _Vector_impl_data {

      pointer _M_start;

      pointer _M_finish;

    };

    struct _Vector_impl : _Tp_alloc_type, _Vector_impl_data {};

    _Tp_alloc_type _M_get_Tp_allocator();

    _Vector_base(long, _Alloc) {

      _M_impl._M_start = _M_allocate();

      _M_impl._M_finish = _M_impl._M_start;

    }

    ~_Vector_base() { _M_deallocate(_M_impl._M_start); }

    _Vector_impl _M_impl;

    long _M_allocate___n;

    pointer _M_allocate() {

      typedef __alloc_traits<_Tp_alloc_type> _Tr;

      return _M_allocate___n ? _Tr::allocate(_M_impl, _M_allocate___n)

        : pointer();

    }

    long _M_deallocate___n;

    void _M_deallocate(pointer __p) {

      typedef __alloc_traits<_Tp_alloc_type> _Tr;

      if (__p)

        _Tr::deallocate(_M_impl, __p, _M_deallocate___n);

    }

  };

  template <typename _Tp, typename _Alloc = new_allocator<_Tp>>

  class vector : _Vector_base<_Tp, _Alloc> {

    typedef _Vector_base<_Tp, _Alloc> _Base;

    typedef __normal_iterator<

      typename __alloc_traits<typename _Base::_Tp_alloc_type>::const_pointer,

      int>

    const_iterator;

    using _Base::_M_get_Tp_allocator;



public:

    vector();

    vector(vector &__x) : _Base(0, _M_get_Tp_allocator()) {

      this->_M_impl._M_finish = __uninitialized_copy_a(__x.begin(), __x.end(),

        this->_M_impl._M_start, 0);

    }

    const_iterator begin() noexcept { return this->_M_impl._M_start; }

    const_iterator end() noexcept { return this->_M_impl._M_finish; }

  };

  template <typename _Tp> class __shared_ptr_access {

public:

    using element_type = _Tp;

    element_type *operator->();

  };

  enum syntax_option_type : int;

  template <typename> using _Matcher = function<bool()>;

  struct _NFA {

    void _M_insert_matcher(_Matcher<int>);

  };

  template <typename _TraitsT> class _Compiler {

public:

    typedef typename _TraitsT::char_type *_IterT;

    _Compiler(_IterT, _IterT, const typename _TraitsT::locale_type &, syntax_option_type);

    template <bool> void _M_insert_character_class_matcher();

    syntax_option_type _M_flags;

    __shared_ptr_access<_NFA> _M_nfa;

    _TraitsT _M_traits;

  };

  template <typename, typename>

  using __enable_if_contiguous_iter =

    __enable_if_t<integral_constant<false>::value,

                  __shared_ptr_access<_NFA>>;

  syntax_option_type __compile_nfa___flags;

  struct Trans_NS___cxx11_regex_traits {

    typedef char char_type;

    typedef int locale_type;

    struct _RegexMask {

      short _M_base;

      char _M_extended;

      _RegexMask() : _M_extended() {}

    } typedef char_class_type;

  };

  template <typename _FwdIter>

  __enable_if_contiguous_iter<_FwdIter, char> __compile_nfa(_FwdIter) {

    auto __cfirst = nullptr;

    using _Cmplr = _Compiler<Trans_NS___cxx11_regex_traits>;

    _Cmplr(__cfirst, __cfirst, 0, __compile_nfa___flags);

  }

  class _RegexTranslatorBase {

public:

    _RegexTranslatorBase(Trans_NS___cxx11_regex_traits);

  };

  class _RegexTranslator : _RegexTranslatorBase {

    typedef _RegexTranslatorBase _Base;

    using _Base::_Base;

  };

  template <typename _TraitsT, int> struct _BracketMatcher {

    _BracketMatcher(bool, _TraitsT __traits) : _M_translator(__traits) {}

    vector<typename _TraitsT::char_class_type> _M_neg_class_set;

    _RegexTranslator _M_translator;

  };

  template <typename _TraitsT>

  _Compiler<_TraitsT>::_Compiler(_IterT __b, _IterT __e,

    const typename _TraitsT::locale_type &__loc,

    syntax_option_type) {

    _M_insert_character_class_matcher<false>();

    _M_insert_character_class_matcher<true>();

  }

  template <typename _TraitsT>

  template <bool __collate>

  void _Compiler<_TraitsT>::_M_insert_character_class_matcher() {

    _BracketMatcher<_TraitsT, __collate> __matcher(0, _M_traits);

    _M_nfa->_M_insert_matcher(__matcher);

  }

  class Trans_NS___cxx11_basic_regex {

public:

    char Trans_NS___cxx11_basic_regex___last;

    Trans_NS___cxx11_basic_regex()

      : _M_automaton(__compile_nfa(Trans_NS___cxx11_basic_regex___last)) {}  /* { dg-error } */

    __shared_ptr_access<_NFA> _M_automaton;

  } regex_sanity_check___f;

}