BOOST_STL_INTERFACES_USE_CONCEPTS
BOOST_STL_INTERFACES_USE_DEDUCED_THIS
BOOST_STL_INTERFACES_NAMESPACE_V1
BOOST_STL_INTERFACES_NAMESPACE_V2
BOOST_STL_INTERFACES_NAMESPACE_V3

namespace boost {
  namespace stl_interfaces {
    enum element_layout;
  }
}

BOOST_STL_INTERFACES_STATIC_ASSERT_CONCEPT(type, concept_name)
BOOST_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS(iter, category, concept, value_type, reference, pointer, difference_type)

namespace boost {
  namespace stl_interfaces {
    struct access;
    template<typename Derived, typename IteratorConcept, typename ValueType, 
             typename Reference, typename Pointer, typename DifferenceType> 
      struct iterator_interface;
    template<typename T> struct proxy_arrow_result;
    typedef iterator_interface< Derived, IteratorConcept, ValueType, Reference, proxy_arrow_result< Reference >, DifferenceType > proxy_iterator_interface;
    template<typename IteratorInterface1, typename IteratorInterface2, 
             typename Enable = std::enable_if_t<!v1_dtl::ra_iter<IteratorInterface1>::value> > 
      decltype(access::base(std::declval< IteratorInterface1 & >())==access::base(std::declval< IteratorInterface2 & >())) 
      operator==(IteratorInterface1, IteratorInterface2);
    template<typename IteratorInterface1, typename IteratorInterface2> 
      decltype(v1_dtl::derived_iterator(lhs), !(lhs==rhs)) 
      operator!=(IteratorInterface1, IteratorInterface2);
    template<typename IteratorInterface1, typename IteratorInterface2> 
      unspecified operator<(IteratorInterface1, IteratorInterface2);
    template<typename IteratorInterface1, typename IteratorInterface2> 
      unspecified operator<=(IteratorInterface1, IteratorInterface2);
    template<typename IteratorInterface1, typename IteratorInterface2> 
      unspecified operator>(IteratorInterface1, IteratorInterface2);
    template<typename IteratorInterface1, typename IteratorInterface2> 
      unspecified operator>=(IteratorInterface1, IteratorInterface2);
    template<typename D> auto operator+(D it, typename D::difference_type n);
    template<typename D> auto operator+(typename D::difference_type n, D it);
    template<typename D1, typename D2> auto operator-(D1 lhs, D2 rhs);
    template<typename D> auto operator-(D it, typename D::difference_type n);
    template<typename D1, typename D2> bool operator<(D1 lhs, D2 rhs);
    template<typename D1, typename D2> bool operator<=(D1 lhs, D2 rhs);
    template<typename D1, typename D2> bool operator>(D1 lhs, D2 rhs);
    template<typename D1, typename D2> bool operator>=(D1 lhs, D2 rhs);
    template<typename D1, typename D2> bool operator==(D1 lhs, D2 rhs);
    template<typename D1, typename D2> 
      decltype(!(lhs==rhs)) operator!=(D1 lhs, D2 rhs);
    template<typename D> auto operator+(D it, typename D::difference_type n);
    template<typename D> auto operator+(typename D::difference_type n, D it);
    template<typename D1, typename D2> auto operator-(D1 lhs, D2 rhs);
    template<typename D> auto operator-(D it, typename D::difference_type n);
    template<typename D1, typename D2> bool operator<(D1 lhs, D2 rhs);
    template<typename D1, typename D2> bool operator<=(D1 lhs, D2 rhs);
    template<typename D1, typename D2> bool operator>(D1 lhs, D2 rhs);
    template<typename D1, typename D2> bool operator>=(D1 lhs, D2 rhs);
    template<typename D1, typename D2> bool operator==(D1 lhs, D2 rhs);
    template<typename D1, typename D2> 
      decltype(!(lhs==rhs)) operator!=(D1 lhs, D2 rhs);
    namespace v1_dtl {
      template<typename Iterator, typename DifferenceType, typename = void> 
        struct plus_eq;

      template<typename Iterator, typename DifferenceType> 
        struct plus_eq<Iterator, DifferenceType, void_t< decltype(std::declval< Iterator & >()+=std::declval< DifferenceType >())>>;

      template<typename Iterator, typename = void> struct ra_iter;

      template<typename Iterator> 
        struct ra_iter<Iterator, void_t< typename Iterator::iterator_concept >>;
      template<typename D, typename IteratorConcept, typename ValueType, 
               typename Reference, typename Pointer, typename DifferenceType> 
        void derived_iterator(iterator_interface< D, IteratorConcept, ValueType, Reference, Pointer, DifferenceType > const &);
    }
    namespace v2_dtl {
      template<typename D, typename IteratorConcept, typename ValueType, 
               typename Reference, typename Pointer, typename DifferenceType> 
        void derived_iterator(v2::iterator_interface< D, IteratorConcept, ValueType, Reference, Pointer, DifferenceType > const &);
    }
    namespace v3_dtl {
      template<typename IteratorConcept, typename ValueType, 
               typename Reference, typename Pointer, typename DifferenceType> 
        void derived_iterator(v3::iterator_interface< IteratorConcept, ValueType, Reference, Pointer, DifferenceType > const &);
    }
  }
}

namespace boost {
  namespace stl_interfaces {
    template<typename BidiIter> 
      decltype(rhs.base()==lhs.base()) 
      operator==(reverse_iterator< BidiIter > lhs, 
                 reverse_iterator< BidiIter > rhs);
    template<typename BidiIter1, typename BidiIter2> 
      decltype(rhs.base()==lhs.base()) 
      operator==(reverse_iterator< BidiIter1 > lhs, 
                 reverse_iterator< BidiIter2 > rhs);
    template<typename BidiIter> auto make_reverse_iterator(BidiIter);
  }
}

namespace boost {
  namespace stl_interfaces {
    template<typename Derived, element_layout Contiguity> 
      struct sequence_container_interface;
    template<typename ContainerInterface> 
      decltype(v1_dtl::derived_container(lhs), lhs.swap(rhs)) 
      swap(ContainerInterface &, ContainerInterface &);
    template<typename ContainerInterface> 
      decltype(v1_dtl::derived_container(lhs), lhs.size()==rhs.size(), *lhs.begin()== *rhs.begin(), true) 
      operator==(ContainerInterface const &, ContainerInterface const &);
    template<typename ContainerInterface> 
      decltype(v1_dtl::derived_container(lhs), lhs==rhs) 
      operator!=(ContainerInterface const &, ContainerInterface const &);
    template<typename ContainerInterface> 
      decltype(v1_dtl::derived_container(lhs), *lhs.begin()< *rhs.begin(), true) 
      operator<(ContainerInterface const &, ContainerInterface const &);
    template<typename ContainerInterface> 
      decltype(v1_dtl::derived_container(lhs), lhs< rhs) 
      operator<=(ContainerInterface const &, ContainerInterface const &);
    template<typename ContainerInterface> 
      decltype(v1_dtl::derived_container(lhs), lhs< rhs) 
      operator>(ContainerInterface const &, ContainerInterface const &);
    template<typename ContainerInterface> 
      decltype(v1_dtl::derived_container(lhs), lhs< rhs) 
      operator>=(ContainerInterface const &, ContainerInterface const &);
    namespace v1_dtl {
      template<typename D, typename = void> struct clear_impl;

      template<typename D> 
        struct clear_impl<D, void_t< decltype(std::declval< D >().clear())>>;

      typedef std::is_convertible< typename std::iterator_traits< Iter >::iterator_category, std::input_iterator_tag > in_iter;
      template<typename D, element_layout Contiguity> 
        void derived_container(sequence_container_interface< D, Contiguity > const &);
    }
  }
}

namespace boost {
  namespace stl_interfaces {
    template<typename F> struct adaptor;
    template<typename F> struct closure;
    template<typename D, typename> struct range_adaptor_closure;
    template<typename Func, typename... Args> 
      auto bind_back(Func &&, Args &&...);
  }
}

namespace boost {
  namespace stl_interfaces {
    template<typename Derived, element_layout Contiguity> struct view_interface;

     BOOST_STL_INTERFACES_NAMESPACE_V1;
     BOOST_STL_INTERFACES_NAMESPACE_V2;
     BOOST_STL_INTERFACES_NAMESPACE_V3;
    template<typename ViewInterface> 
      decltype(v1_dtl::derived_view(lhs), !(lhs==rhs)) 
      operator!=(ViewInterface, ViewInterface);
    namespace v1_dtl {
      template<typename D, element_layout Contiguity> 
        void derived_view(view_interface< D, Contiguity > const &);
    }
  }
}