namespace boost {
  template<typename Value, typename CategoryOrTraversal, 
           typename Reference = Value&, typename Difference = std::ptrdiff_t> 
    class any_iterator;

  template<typename iterator> struct make_any_iterator_type;
}

namespace boost {
  template<typename X> struct ConsumerConcept;
  template<typename X> struct BoundaryCheckerConcept;
}

namespace boost {
  template<typename Pipe> struct pipe_consumer;
  template<typename BoundaryChecker> struct boundary_consumer;
  template<typename B1, typename Pipe, typename B2> struct multi_boundary;
  template<typename Pipe, typename Consumer> struct piped_consumer;
  template<typename Pipe> pipe_consumer< Pipe > make_pipe_consumer(Pipe);
  template<typename BoundaryChecker> 
    boundary_consumer< BoundaryChecker > 
    make_boundary_consumer(BoundaryChecker);
  template<typename B1, typename Pipe, typename B2> 
    multi_boundary< B1, Pipe, B2 > make_multi_boundary(B1, Pipe, B2);
  template<typename Pipe, typename Consumer> 
    piped_consumer< Pipe, Consumer > make_piped_consumer(Pipe, Consumer);
  template<typename It, typename Consumer> 
    consumer_iterator< It, Consumer > 
    make_consumer_iterator(It, It, It, Consumer);
  template<typename Range, typename Consumer> 
    iterator_range< consumer_iterator< typename range_iterator< const Range >::type, Consumer > > 
    consumed(const Range &, Consumer);
  template<typename Range, typename Consumer> 
    iterator_range< consumer_iterator< typename range_iterator< Range >::type, Consumer > > 
    consumed(Range &, Consumer);
}

namespace boost {
  template<typename It, typename Consumer> struct consumer_iterator;
}

namespace boost {
  template<typename Tuple> struct join_iterator;
  struct range_transformer;
  struct fused_make_range_tuple;
  template<typename Tuple> 
    join_iterator< Tuple > make_join_end_iterator(const Tuple & tuple);
  template<typename Tuple> 
    join_iterator< Tuple > make_join_iterator(const Tuple & tuple);
  template<typename Tuple> 
    iterator_range< join_iterator< Tuple >> joined(const Tuple & tuple);
  template<typename... T> 
    iterator_range< join_iterator< tuple< T...> >> joined_n(const T &... n);
}

namespace boost {
  template<typename X> struct PipeConcept;
  template<typename X> struct OneManyPipeConcept;
}

namespace boost {
  template<typename OneManyPipe> struct one_many_pipe;
  template<typename P1, typename P2> struct multi_pipe;
  template<typename P1, typename P2> struct piped_pipe;
  template<typename T> struct cast_pipe;
  template<typename P1, typename P2> 
    multi_pipe< P1, P2 > make_multi_pipe(P1, P2);
  template<typename P1, typename P2> 
    piped_pipe< P1, P2 > make_piped_pipe(P1, P2);
  template<typename It, typename Pipe> 
    pipe_iterator< It, Pipe > make_pipe_iterator(It, It, It, Pipe);
  template<typename Range, typename Pipe> 
    iterator_range< pipe_iterator< typename range_iterator< const Range >::type, Pipe > > 
    piped(const Range &, Pipe);
  template<typename Range, typename Pipe> 
    iterator_range< pipe_iterator< typename range_iterator< Range >::type, Pipe > > 
    piped(Range &, Pipe);
  template<typename Range, typename Pipe, typename OutputIterator> 
    OutputIterator pipe(const Range &, Pipe, OutputIterator);
  template<typename OutputIterator, typename OneManyPipe> 
    pipe_output_iterator< OutputIterator, OneManyPipe > 
    piped_output(OutputIterator, OneManyPipe);
}

namespace boost {
  template<typename It, typename Pipe> struct pipe_iterator;
  template<typename OutputIterator, typename OneManyPipe> 
    struct pipe_output_iterator;
}

namespace boost {
  template<typename Value, typename CategoryOrTraversal, 
           typename Reference = Value&, typename Difference = std::ptrdiff_t> 
    struct any_range;
  template<typename Value, typename Reference = const Value, 
           typename Difference = std::ptrdiff_t> 
    struct lazy_range;
}