namespace boost {
  namespace type_erasure {
    template<typename T, typename Concept, typename Tag> 
      T any_cast(any< Concept, Tag > &);
    template<typename T, typename Concept, typename Tag> 
      T any_cast(const any< Concept, Tag > &);
    template<typename T, typename Concept, typename Tag> 
      T any_cast(any< Concept, Tag > *);
    template<typename T, typename Concept, typename Tag> 
      T any_cast(const any< Concept, Tag > *);
  }
}

namespace boost {
  namespace type_erasure {
    template<typename P> class dynamic_binding;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename T> 
      const binding< Concept > & binding_of(const any< Concept, T > &);
  }
}

namespace boost {
  namespace type_erasure {
    template<typename T = _self> struct destructible;
    template<typename T = _self> struct copy_constructible;
    template<typename T = _self, typename U = T> struct assignable;
    template<typename T = _self> struct typeid_;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename Op, class... U> 
      unspecified call(const binding< Concept > &, const Op &, U &&...);
    template<typename Op, class... U> unspecified call(const Op &, U &&...);
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Sig, typename F = _self> struct callable;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename Op, class... U> 
      bool check_match(const binding< Concept > &, const Op &, U &&...);
    template<typename Op, class... U> bool check_match(const Op &, U &&...);
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename Base, typename ID, 
             typename Enable = void> 
      struct concept_interface;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename T> struct concept_of;
  }
}

BOOST_TYPE_ERASURE_MAX_FUNCTIONS
BOOST_TYPE_ERASURE_MAX_ARITY
BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE

namespace boost {
  namespace type_erasure {
    template<typename Sig> struct constructible;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Metafunction> struct deduced;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename T> struct derived;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename R, typename Any> R dynamic_any_cast(Any &&);
    template<typename R, typename Any, typename Map> 
      R dynamic_any_cast(Any &&, const static_binding< Map > &);
  }
}

namespace boost {
  namespace type_erasure {
    class bad_function_call;
    class bad_any_cast;
  }
}

BOOST_TYPE_ERASURE_FREE(qualified_name, function_name, N)

namespace boost {
  namespace type_erasure {
    template<typename T> bool is_empty(const T &);
  }
}

namespace boost {
  namespace type_erasure {
    template<typename T> struct is_placeholder;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Sub, typename Super, typename PlaceholderMap = void> 
      struct is_subconcept;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Traversal, typename T = _self, 
             typename Reference = ::boost::use_default, 
             typename DifferenceType = ::std::ptrdiff_t, 
             typename ValueType = typename deduced<iterator_value_type<T> >::type> 
      struct iterator;
    template<typename T = _self, typename Reference = boost::use_default, 
             typename DifferenceType = std::ptrdiff_t> 
      struct forward_iterator;
    template<typename T = _self, typename Reference = boost::use_default, 
             typename DifferenceType = std::ptrdiff_t> 
      struct bidirectional_iterator;
    template<typename T = _self, typename Reference = boost::use_default, 
             typename DifferenceType = std::ptrdiff_t> 
      struct random_access_iterator;
  }
}

BOOST_TYPE_ERASURE_MEMBER(qualified_name, member, N)

namespace boost {
  namespace type_erasure {
    template<typename T = _self> struct incrementable;
    template<typename T = _self> struct decrementable;
    template<typename T = _self, typename R = T> struct complementable;
    template<typename T = _self, typename R = T> struct negatable;
    template<typename R, typename T = _self> struct dereferenceable;
    template<typename T = _self, typename U = T, typename R = T> struct addable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct subtractable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct multipliable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct dividable;
    template<typename T = _self, typename U = T, typename R = T> struct modable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct left_shiftable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct right_shiftable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct bitandable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct bitorable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct bitxorable;
    template<typename T = _self, typename U = T> struct add_assignable;
    template<typename T = _self, typename U = T> struct subtract_assignable;
    template<typename T = _self, typename U = T> struct multiply_assignable;
    template<typename T = _self, typename U = T> struct divide_assignable;
    template<typename T = _self, typename U = T> struct mod_assignable;
    template<typename T = _self, typename U = T> struct left_shift_assignable;
    template<typename T = _self, typename U = T> struct right_shift_assignable;
    template<typename T = _self, typename U = T> struct bitand_assignable;
    template<typename T = _self, typename U = T> struct bitor_assignable;
    template<typename T = _self, typename U = T> struct bitxor_assignable;
    template<typename T = _self, typename U = T> struct equality_comparable;
    template<typename T = _self, typename U = T> struct less_than_comparable;
    template<typename R, typename T = _self, typename N = std::ptrdiff_t> 
      struct subscriptable;
    template<typename Os = std::ostream, typename T = _self> struct ostreamable;
    template<typename Is = std::istream, typename T = _self> struct istreamable;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept> class binding;
    template<typename Any, typename T> struct as_param;
  }
}

namespace boost {
  namespace type_erasure {
    struct placeholder;
    struct _a;
    struct _b;
    struct _c;
    struct _d;
    struct _e;
    struct _f;
    struct _g;
    struct _self;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename T> class any;
    template<typename Concept, typename T> class param;
    template<typename T> struct placeholder_of;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Any, typename T> struct rebind_any;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename Map> 
      void register_binding(const static_binding< Map > &);
    template<typename Concept, typename T> void register_binding();
  }
}

namespace boost {
  namespace type_erasure {
    template<typename T> struct is_relaxed;
    struct relaxed;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename Op, class... U> 
      void require_match(const binding< Concept > &, const Op &, U &&...);
    template<typename Op, class... U> void require_match(const Op &, U &&...);
  }
}

namespace boost {
  namespace type_erasure {
    template<typename T, typename U> struct same_type;
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Map> struct static_binding;
    template<typename Map> static_binding< Map > make_binding();
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, class... T> class tuple;
    template<int N, typename Concept, class... T> 
      any< Concept, TN > & get(tuple< Concept, T...> &);
    template<int N, typename Concept, class... T> 
      const any< Concept, TN > & get(const tuple< Concept, T...> &);
  }
}

namespace boost {
  namespace type_erasure {
    template<typename Concept, typename T> 
      const std::type_info & typeid_of(const any< Concept, T > &);
    template<typename T, typename Concept> 
      const std::type_info & typeid_of(const binding< Concept > &);
  }
}