namespace boost {
  namespace double_ended {
    template<typename T, typename BatchDequePolicy = batch_deque_policy<512>, 
             typename Allocator = std::allocator<T> > 
      class batch_deque;

    template<std::size_t SegmentSize> struct batch_deque_policy;
    template<typename T, typename PX, typename AX, typename PY, typename AY> 
      bool operator==(const batch_deque< T, PX, AX > & x, 
                      const batch_deque< T, PY, AY > & y);
    template<typename T, typename PX, typename AX, typename PY, typename AY> 
      bool operator<(const batch_deque< T, PX, AX > & x, 
                     const batch_deque< T, PY, AY > & y);
    template<typename T, typename PX, typename AX, typename PY, typename AY> 
      bool operator!=(const batch_deque< T, PX, AX > & x, 
                      const batch_deque< T, PY, AY > & y);
    template<typename T, typename PX, typename AX, typename PY, typename AY> 
      bool operator>(const batch_deque< T, PX, AX > & x, 
                     const batch_deque< T, PY, AY > & y);
    template<typename T, typename PX, typename AX, typename PY, typename AY> 
      bool operator>=(const batch_deque< T, PX, AX > & x, 
                      const batch_deque< T, PY, AY > & y);
    template<typename T, typename PX, typename AX, typename PY, typename AY> 
      bool operator<=(const batch_deque< T, PX, AX > & x, 
                      const batch_deque< T, PY, AY > & y);
    template<typename T, typename P, typename Allocator> 
      void swap(batch_deque< T, P, Allocator > & x, 
                batch_deque< T, P, Allocator > & y);
  }
}

namespace boost {
  namespace double_ended {
    template<typename T, typename SmallBufferPolicy = small_buffer_size<0>, 
             typename GrowthPolicy = devector_growth_policy, 
             typename Allocator = std::allocator<T> > 
      class devector;

    struct devector_growth_policy;
    struct reserve_only_tag;
    template<unsigned Size> struct small_buffer_size;
    struct unsafe_uninitialized_tag;
    template<typename T, typename AllocatorX, typename SBPX, typename GPX, 
             typename AllocatorY, typename SBPY, typename GPY> 
      bool operator==(const devector< T, AllocatorX, SBPX, GPX > & x, 
                      const devector< T, AllocatorY, SBPY, GPY > & y);
    template<typename T, typename AllocatorX, typename SBPX, typename GPX, 
             typename AllocatorY, typename SBPY, typename GPY> 
      bool operator<(const devector< T, AllocatorX, SBPX, GPX > & x, 
                     const devector< T, AllocatorY, SBPY, GPY > & y);
    template<typename T, typename AllocatorX, typename SBPX, typename GPX, 
             typename AllocatorY, typename SBPY, typename GPY> 
      bool operator!=(const devector< T, AllocatorX, SBPX, GPX > & x, 
                      const devector< T, AllocatorY, SBPY, GPY > & y);
    template<typename T, typename AllocatorX, typename SBPX, typename GPX, 
             typename AllocatorY, typename SBPY, typename GPY> 
      bool operator>(const devector< T, AllocatorX, SBPX, GPX > & x, 
                     const devector< T, AllocatorY, SBPY, GPY > & y);
    template<typename T, typename AllocatorX, typename SBPX, typename GPX, 
             typename AllocatorY, typename SBPY, typename GPY> 
      bool operator>=(const devector< T, AllocatorX, SBPX, GPX > & x, 
                      const devector< T, AllocatorY, SBPY, GPY > & y);
    template<typename T, typename AllocatorX, typename SBPX, typename GPX, 
             typename AllocatorY, typename SBPY, typename GPY> 
      bool operator<=(const devector< T, AllocatorX, SBPX, GPX > & x, 
                      const devector< T, AllocatorY, SBPY, GPY > & y);
    template<typename T, typename Allocator, typename SBP, typename GP> 
      void swap(devector< T, Allocator, SBP, GP > & x, 
                devector< T, Allocator, SBP, GP > & y);
  }
}

namespace boost {
  namespace serialization {
    template<typename Archive, typename T, typename BDP, typename A> 
      void save(Archive & ar, const batch_deque< T, BDP, A > & c, unsigned);
    template<typename Archive, typename T, typename BDP, typename A> 
      void load(Archive & ar, batch_deque< T, BDP, A > & c, unsigned);
    template<typename Archive, typename T, typename BDP, typename A> 
      void serialize(Archive & ar, batch_deque< T, BDP, A > & c, 
                     unsigned version);
  }
}

namespace boost {
  namespace serialization {
    typedef unspecified de_alloc_traits;
    template<typename Archive, typename T, typename SBP, typename GP, 
             typename A> 
      void save(Archive & ar, const devector< T, SBP, GP, A > & c, unsigned);
    template<typename Archive, typename T, typename SBP, typename GP, 
             typename A> 
      void load(Archive & ar, devector< T, SBP, GP, A > & c, unsigned);
    template<typename Archive, typename T, typename SBP, typename GP, 
             typename A> 
      void serialize(Archive & ar, devector< T, SBP, GP, A > & c, 
                     unsigned version);
  }
}