#ifndef MultimethodH
#define MultimethodH
/*---------------------------------------------------------------------------
   Multimethod.hpp

   ---------------------------------------------------------------------------
   Copyright (C) 2009/01 - 2009 Nowake nowake@fircewinds.net

----------------------------------------------------------------------------*/

#include <map>
#include <boost/type_traits.hpp>
#include <boost/any.hpp>
#include <boost/unordered_map.hpp>
#include <loki/LokiTypeInfo.h>


namespace Loki {
   std::size_t hash_value(const TypeInfo& value) {
      boost::hash<const std::type_info*> hasher;
      return hasher(&(value.Get()));
   }
}

//////////////////////////////////////////////////////////////////////////////
// multi method executor
//////////////////////////////////////////////////////////////////////////////
struct Multimethod {
   Multimethod() {};
public: //////////////////////////////////////////////////////////////////////
   template<typename holder_t> struct ArgumentTraits;
   template<typename R>
   struct ApplyTraits {
      template<typename A00> R operator()(A00& a00) { return a00(); };
      template<typename A00, typename A01> R operator()(A00& a00, A01& a01) { return a00(a01); };
      template<typename A00, typename A01, typename A02> R operator()(A00& a00, A01& a01, A02& a02) { return a00(a01, a02); };
      template<typename A00, typename A01, typename A02, typename A03> R operator()(A00& a00, A01& a01, A02& a02, A03& a03) { return a00(a01, a02, a03); };
   };
   template<>
   struct ApplyTraits<void> {
      template<typename A00> void operator()(A00& a00) { a00(); };
      template<typename A00, typename A01> void operator()(A00& a00, A01& a01) { a00(a01); };
      template<typename A00, typename A01, typename A02> void operator()(A00& a00, A01& a01, A02& a02) { a00(a01, a02); };
      template<typename A00, typename A01, typename A02, typename A03> void operator()(A00& a00, A01& a01, A02& a02, A03& a03) { a00(a01, a02, a03); };
   };
   ///////////////////////////////////////////////////////////////////////////
   template<typename R>
   struct ReturnEmptyValue {
      template<typename A00> R operator()(A00& a00) { a00(); return R(); };
      template<typename A00, typename A01> R operator()(A00& a00, A01& a01) { a00(a01); return R(); };
      template<typename A00, typename A01, typename A02> R operator()(A00& a00, A01& a01, A02& a02) { a00(a01, a02); return R(); };
      template<typename A00, typename A01, typename A02, typename A03> R operator()(A00& a00, A01& a01, A02& a02, A03& a03) { a00(a01, a02, a03); return R(); };
   };
public: //////////////////////////////////////////////////////////////////////
   class BadMultimethod : public std::bad_cast {
   public:
      virtual const char * what() const throw() {
         return "Bad Multimethod apply: no entried argument set.";
      };
   };
private: /////////////////////////////////////////////////////////////////////
   template<typename R, typename T, unsigned int N> class map {
   public:
      typedef map<R, T, N-1> item_type;
      typedef std::map<const T, item_type> map_type;
      //typedef boost::unordered_map<const T, item_type> map_type;
      item_type& find(const T& t) {
         std::pair<map_type::iterator, bool> r(d_.insert(make_pair(t, item_type())));
         return r.first->second;
      }
   private:
      map_type d_;
   };
   template<typename R, typename T> struct map<R, T, 0> {
   public:
      typedef R item_type;
      typedef std::map<const T, item_type> map_type;
      //typedef boost::unordered_map<const T, item_type> map_type;
      item_type& find(const T& t) {
         std::pair<map_type::iterator, bool> r(d_.insert(make_pair(t, item_type())));
         return r.first->second;
      }
   private:
      map_type d_;
   };
   template<typename R, typename T>
   static R& find(const T& t00) {
      static map<R, T, 0> m;
      return m.find(t00);
   };
   template<typename R, typename T>
   static R& find(const T& t00, const T& t01) {
      static map<R, T, 1> m;
      return m.find(t00).find(t01);
   };
   template<typename R, typename T>
   static R& find(const T& t00, const T& t01, const T& t02) {
      static map<R, T, 2> m;
      return m.find(t00).find(t01).find(t02);
   };
   template<typename R, typename T>
   static R& find(const T& t00, const T& t01, const T& t02, const T& t03) {
      static map<R, T, 3> m;
      return m.find(t00).find(t01).find(t02).find(t03);
   };
private:////////////////////////////////////////////////////////////////////////
   template<typename R, typename HHH, typename A00, typename A>
   struct Apply00 {
      static A& apply() { static A a; return a; };
      static R trampoline(HHH& a00) { return apply()(ArgumentTraits<HHH>::cast<A00&>(a00)); };
   };
public:
   template<typename R, typename HHH, typename A00>
   static bool entry() { return entry<R, HHH, A00>(ApplyTraits<R>()); };
   template<typename R, typename HHH, typename A00, typename A>
   static bool entry(A apply) {
      typedef R (*T00)(HHH&);
      find<T00>(ArgumentTraits<HHH>::id<A00>()) = &Apply00<R, HHH, A00, A>::trampoline;
      Apply00<R, HHH, A00, A>::apply() = apply;
      return true;
   };
   template<typename R, typename HHH>
   static R apply(HHH& a00) {
      typedef R (*T)(HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00)));
      if (!t) throw BadMultimethod();
      return t(a00);
   };
private:////////////////////////////////////////////////////////////////////////
   template<typename R, typename HHH, typename A00, typename A01, typename A>
   struct Apply01 {
      static A& apply() { static A a; return a; };
      static R trampoline(HHH& a00, HHH& a01) { return apply()(ArgumentTraits<HHH>::cast<A00&>(a00), ArgumentTraits<HHH>::cast<A01&>(a01)); };
      static R trampoline(A00& a00, HHH& a01) { return apply()(a00, ArgumentTraits<HHH>::cast<A01&>(a01)); };
      static R trampoline(HHH& a00, A01& a01) { return apply()(ArgumentTraits<HHH>::cast<A00&>(a00), a01); };
   };
public:
   template<typename R, typename HHH, typename A00, typename A01>
   static bool entry() { return entry<R, HHH, A00, A01>(ApplyTraits<R>()); };
   template<typename R, typename HHH, typename A00, typename A01, typename A>
   static bool entry(A apply) {
      typedef R (*T00)(HHH&, HHH&);
      find<T00>(ArgumentTraits<HHH>::id<A00>(), ArgumentTraits<HHH>::id<A01>()) = &Apply01<R, HHH, A00, A01, A>::trampoline;
      typedef R (*T01)(A00&, HHH&);
      find<T01>(ArgumentTraits<HHH>::id<A01>()) = &Apply01<R, HHH, A00, A01, A>::trampoline;
      typedef R (*T02)(HHH&, A01&);
      find<T02>(ArgumentTraits<HHH>::id<A00>()) = &Apply01<R, HHH, A00, A01, A>::trampoline;
      Apply01<R, HHH, A00, A01, A>::apply() = apply;
      return true;
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(T00& a00, T01& a01) {
      typedef R (*T)(T00&, T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01);
   };
   template<typename R, typename HHH>
   static R apply(HHH& a00, HHH& a01) {
      typedef R (*T)(HHH&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(T00& a00, HHH& a01, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(HHH& a00, T00& a01, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, T00&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00)));
      if (!t) throw BadMultimethod();
      return t(a00, a01);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(const T00& a00, HHH& a01, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(HHH& a00, const T00& a01, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, const T00&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00)));
      if (!t) throw BadMultimethod();
      return t(a00, a01);
   };
private: ///////////////////////////////////////////////////////////////////////
   template<typename R, typename HHH, typename A00, typename A01, typename A02, typename A>
   struct Apply02 {
      static A& apply() { static A a; return a; };
      static R trampoline(HHH& a00, HHH& a01, HHH& a02) { return apply()(ArgumentTraits<HHH>::cast<A00&>(a00), ArgumentTraits<HHH>::cast<A01&>(a01), ArgumentTraits<HHH>::cast<A02&>(a02)); };
      static R trampoline(A00& a00, HHH& a01, HHH& a02) { return apply()(a00, ArgumentTraits<HHH>::cast<A01&>(a01), ArgumentTraits<HHH>::cast<A02&>(a02)); };
      static R trampoline(HHH& a00, A01& a01, HHH& a02) { return apply()(ArgumentTraits<HHH>::cast<A00&>(a00), a01, ArgumentTraits<HHH>::cast<A02&>(a02)); };
      static R trampoline(HHH& a00, HHH& a01, A02& a02) { return apply()(ArgumentTraits<HHH>::cast<A00&>(a00), ArgumentTraits<HHH>::cast<A01&>(a01), a02); };
      static R trampoline(HHH& a00, A01& a01, A02& a02) { return apply()(ArgumentTraits<HHH>::cast<A00&>(a00), a01, a02); };
      static R trampoline(A00& a00, HHH& a01, A02& a02) { return apply()(a00, ArgumentTraits<HHH>::cast<A01&>(a01), a02); };
      static R trampoline(A00& a00, A01& a01, HHH& a02) { return apply()(a00, a01, ArgumentTraits<HHH>::cast<A02&>(a02)); };
   };
public:
   template<typename R, typename HHH, typename A00, typename A01, typename A02>
   static bool entry() { return entry<R, HHH, A00, A01, A02>(ApplyTraits<R>()); };
   template<typename R, typename HHH, typename A00, typename A01, typename A02, typename A>
   static bool entry(A apply) {
      typedef R (*T00)(HHH&, HHH&, HHH&);
      find<T00>(ArgumentTraits<HHH>::id<A00>(), ArgumentTraits<HHH>::id<A01>(), ArgumentTraits<HHH>::id<A02>()) = &Apply02<R, HHH, A00, A01, A02, A>::trampoline;
      typedef R (*T01)(A00&, HHH&, HHH&);
      find<T01>(ArgumentTraits<HHH>::id<A01>(), ArgumentTraits<HHH>::id<A02>()) = &Apply02<R, HHH, A00, A01, A02, A>::trampoline;
      typedef R (*T02)(HHH&, A01&, HHH&);
      find<T02>(ArgumentTraits<HHH>::id<A00>(), ArgumentTraits<HHH>::id<A02>()) = &Apply02<R, HHH, A00, A01, A02, A>::trampoline;
      typedef R (*T03)(HHH&, HHH&, A02&);
      find<T02>(ArgumentTraits<HHH>::id<A00>(), ArgumentTraits<HHH>::id<A01>()) = &Apply02<R, HHH, A00, A01, A02, A>::trampoline;
      typedef R (*T04)(HHH&, A01&, A02&);
      find<T04>(ArgumentTraits<HHH>::id<A00>()) = &Apply02<R, HHH, A00, A01, A02, A>::trampoline;
      typedef R (*T05)(A00&, HHH&, A02&);
      find<T05>(ArgumentTraits<HHH>::id<A01>()) = &Apply02<R, HHH, A00, A01, A02, A>::trampoline;
      typedef R (*T06)(A00&, A01&, HHH&);
      find<T06>(ArgumentTraits<HHH>::id<A02>()) = &Apply02<R, HHH, A00, A01, A02, A>::trampoline;
      Apply02<R, HHH, A00, A01, A02, A>::apply() = apply;
      return true;
   };
   template<typename R, typename HHH>
   static R apply(HHH& a00, HHH& a01, HHH& a02) {
      typedef R (*T)(HHH&, HHH&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(T00& a00, HHH& a01, HHH& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, HHH&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(HHH& a00, T00& a01, HHH& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, T00&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(ma02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(HHH& a00, HHH& a01, T00& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, T00& a01, T01& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, T00&, T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(T00& a00, HHH& a01, T01& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, HHH&, T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(T00& a00, T01& a01, HHH& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, T01&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(const T00& a00, HHH& a01, HHH& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, HHH&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(HHH& a00, const T00& a01, HHH& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, const T00&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(ma02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(HHH& a00, HHH& a01, const T00& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, HHH&, const T00);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, const T00& a01, T01& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, const T00&, T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, T00& a01, const T01& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, T00&, const T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, const T00& a01, const T01& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, const T00&, const T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(const T00& a00, HHH& a01, T01& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, HHH&, T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(T00& a00, HHH& a01, const T01& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, HHH&, const T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(const T00& a00, HHH& a01, const T01& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, HHH&, const T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(const T00& a00, T01& a01, HHH& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, T01&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(T00& a00, const T01& a01, HHH& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, const T01&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(const T00& a00, const T01& a01, HHH& a02, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, const T01&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02);
   };
private: //////////////////////////////////////////////////////////////////////
   template<typename R, typename HHH, typename A00, typename A01, typename A02, typename A03, typename A>
   struct Apply03 {
      static A& apply() { static A a; return a; };
      static R trampoline(HHH& a00, HHH& a01, HHH& a02, HHH& a03) { return apply()(ArgumentTraits<HHH>::cast<A00&>(a00), ArgumentTraits<HHH>::cast<A01&>(a01), ArgumentTraits<HHH>::cast<A02&>(a02), ArgumentTraits<HHH>::cast<A03&>(a03)); };
      static R trampoline(A00& a00, HHH& a01, HHH& a02, HHH& a03) { return apply()(a00, ArgumentTraits<HHH>::cast<A01&>(a01), ArgumentTraits<HHH>::cast<A02&>(a02), ArgumentTraits<HHH>::cast<A03&>(a03)); };
      static R trampoline(HHH& a00, A01& a01, HHH& a02, HHH& a03) { return apply()(ArgumentTraits<HHH>::cast<A00&>(a00), a01, ArgumentTraits<HHH>::cast<A02&>(a02), ArgumentTraits<HHH>::cast<A03&>(a03)); };
      static R trampoline(HHH& a00, HHH& a01, A02& a02, HHH& a03) { return apply()(ArgumentTraits<HHH>::cast<A00&>(a00), ArgumentTraits<HHH>::cast<A01&>(a01), a02, ArgumentTraits<HHH>::cast<A03&>(a03)); };
      static R trampoline(HHH& a00, HHH& a01, HHH& a02, A03& a03) { return apply()(ArgumentTraits<HHH>::cast<A00&>(a00), ArgumentTraits<HHH>::cast<A01&>(a01), ArgumentTraits<HHH>::cast<A02&>(a02), a03); };
      static R trampoline(A00& a00, A01& a01, HHH& a02, HHH& a03) { return apply()(a00, a01, ArgumentTraits<HHH>::cast<A02&>(a02), ArgumentTraits<HHH>::cast<A03&>(a03)); };
      static R trampoline(A00& a00, HHH& a01, A02& a02, HHH& a03) { return apply()(a00, ArgumentTraits<HHH>::cast<A01&>(a01), a02, ArgumentTraits<HHH>::cast<A03&>(a03)); };
      static R trampoline(A00& a00, HHH& a01, HHH& a02, A03& a03) { return apply()(a00, ArgumentTraits<HHH>::cast<A01&>(a01), ArgumentTraits<HHH>::cast<A02&>(a02), a03); };
      static R trampoline(HHH& a00, A01& a01, A02& a02, HHH& a03) { return apply()(ArgumentTraits<HHH>::cast<A00&>(a00), a01, a02, ArgumentTraits<HHH>::cast<A03&>(a03)); };
      static R trampoline(HHH& a00, A01& a01, HHH& a02, A03& a03) { return apply()(ArgumentTraits<HHH>::cast<A00&>(a00), a01, ArgumentTraits<HHH>::cast<A02&>(a02), a03); };
      static R trampoline(HHH& a00, HHH& a01, A02& a02, A03& a03) { return apply()(ArgumentTraits<HHH>::cast<A00&>(a00), ArgumentTraits<HHH>::cast<A01&>(a01), a02, a03); };
      static R trampoline(HHH& a00, A01& a01, A02& a02, A03& a03) { return apply()(ArgumentTraits<HHH>::cast<A00&>(a00), a01, a02, a03); };
      static R trampoline(A00& a00, HHH& a01, A02& a02, A03& a03) { return apply()(a00, ArgumentTraits<HHH>::cast<A01&>(a01), a02, a03); };
      static R trampoline(A00& a00, A01& a01, HHH& a02, A03& a03) { return apply()(a00, a01, ArgumentTraits<HHH>::cast<A02&>(a02), a03); };
      static R trampoline(A00& a00, A01& a01, A02& a02, HHH& a03) { return apply()(a00, a01, a02, ArgumentTraits<HHH>::cast<A03&>(a03)); };
   };
public:
   template<typename R, typename HHH, typename A00, typename A01, typename A02, typename A03>
   static bool entry() { return entry<R, HHH, A00, A01, A02, A03>(ApplyTraits<R>()); };
   template<typename R, typename HHH, typename A00, typename A01, typename A02, typename A03, typename A>
   static bool entry(A apply) {
      typedef R (*T00)(HHH&, HHH&, HHH&, HHH&);
      find<T00>(ArgumentTraits<HHH>::id<A00>(), ArgumentTraits<HHH>::id<A01>(), ArgumentTraits<HHH>::id<A02>(), ArgumentTraits<HHH>::id<A03>()) = &Apply03<R, HHH, A00, A01, A02, A03, A>::trampoline;
      typedef R (*T01)(A00&, HHH&, HHH&, HHH&);
      find<T01>(ArgumentTraits<HHH>::id<A01>(), ArgumentTraits<HHH>::id<A02>(), ArgumentTraits<HHH>::id<A03>()) = &Apply03<R, HHH, A00, A01, A02, A03, A>::trampoline;
      typedef R (*T02)(HHH&, A01&, HHH&, HHH&);
      find<T02>(ArgumentTraits<HHH>::id<A00>(), ArgumentTraits<HHH>::id<A02>(), ArgumentTraits<HHH>::id<A03>()) = &Apply03<R, HHH, A00, A01, A02, A03, A>::trampoline;
      typedef R (*T03)(HHH&, HHH&, A02&, HHH&);
      find<T03>(ArgumentTraits<HHH>::id<A00>(), ArgumentTraits<HHH>::id<A01>(), ArgumentTraits<HHH>::id<A03>()) = &Apply03<R, HHH, A00, A01, A02, A03, A>::trampoline;
      typedef R (*T04)(HHH&, HHH&, HHH&, A03&);
      find<T04>(ArgumentTraits<HHH>::id<A00>(), ArgumentTraits<HHH>::id<A01>(), ArgumentTraits<HHH>::id<A02>()) = &Apply03<R, HHH, A00, A01, A02, A03, A>::trampoline;
      typedef R (*T05)(A00&, A01&, HHH&, HHH&);
      find<T05>(ArgumentTraits<HHH>::id<A02>(), ArgumentTraits<HHH>::id<A03>()) = &Apply03<R, HHH, A00, A01, A02, A03, A>::trampoline;
      typedef R (*T06)(A00&, HHH&, A02&, HHH&);
      find<T06>(ArgumentTraits<HHH>::id<A00>(), ArgumentTraits<HHH>::id<A03>()) = &Apply03<R, HHH, A00, A01, A02, A03, A>::trampoline;
      typedef R (*T07)(A00&, A01&, HHH&, HHH&);
      find<T07>(ArgumentTraits<HHH>::id<A02>(), ArgumentTraits<HHH>::id<A03>()) = &Apply03<R, HHH, A00, A01, A02, A03, A>::trampoline;
      typedef R (*T08)(HHH&, A01&, A02&, A03&);
      find<T08>(ArgumentTraits<HHH>::id<A00>()) = &Apply03<R, HHH, A00, A01, A02, A03, A>::trampoline;
      typedef R (*T09)(A00&, HHH&, A02&, A03&);
      find<T09>(ArgumentTraits<HHH>::id<A01>()) = &Apply03<R, HHH, A00, A01, A02, A03, A>::trampoline;
      typedef R (*T10)(A00&, A01&, HHH&, A03&);
      find<T10>(ArgumentTraits<HHH>::id<A02>()) = &Apply03<R, HHH, A00, A01, A02, A03, A>::trampoline;
      typedef R (*T11)(A00&, A01&, A02&, HHH&);
      find<T11>(ArgumentTraits<HHH>::id<A03>()) = &Apply03<R, HHH, A00, A01, A02, A03, A>::trampoline;
      Apply03<R, HHH, A00, A01, A02, A03, A>::apply() = apply;
      return true;
   };
   template<typename R, typename HHH>
   static R apply(HHH& a00, HHH& a01, HHH& a02, HHH& a03) {
      typedef R (*T)(HHH&, HHH&, HHH&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a02), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(T00& a00, HHH& a01, HHH& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, HHH&, HHH&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a02), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(const T00& a00, HHH& a01, HHH& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, HHH&, HHH&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a02), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(HHH& a00, T00& a01, HHH& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, T00&, HHH&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a02), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(HHH& a00, const T00& a01, HHH& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, const T00&, HHH&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a02), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(HHH& a00, HHH& a01, T00& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, HHH&, T00&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(HHH& a00, HHH& a01, const T00& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, HHH&, const T00&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(HHH& a00, HHH& a01, HHH& a02, T00& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, HHH&, HHH&, T00&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00>
   static R apply(HHH& a00, HHH& a01, HHH& a02, const T00& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, HHH&, HHH&, const T00&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(T00& a00, T01& a01, HHH& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, T01&, HHH&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(const T00& a00, T01& a01, HHH& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, T01&, HHH&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(T00& a00, const T01& a01, HHH& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, const T01&, HHH&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(const T00& a00, const T01& a01, HHH& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, const T01&, HHH&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(T00& a00, HHH& a01, T01& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, HHH&, T01&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(const T00& a00, HHH& a01, T01& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, HHH&, T01&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(T00& a00, HHH& a01, const T01& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, HHH&, const T01&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(const T00& a00, HHH& a01, const T01& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, HHH&, const T01&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(T00& a00, HHH& a01, HHH& a02, T01& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, HHH&, HHH&, T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(const T00& a00, HHH& a01, HHH& a02, T01& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, HHH&, HHH&, T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(T00& a00, HHH& a01, HHH& a02, const T01& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, HHH&, HHH&, const T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(const T00& a00, HHH& a01, HHH& a02, const T01& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, HHH&, HHH&, const T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01), ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, T00& a01, T01& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, T00&, T01&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, const T00& a01, T01& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, const T00&, T01&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, T00& a01, const T01& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, T00&, const T01&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, const T00& a01, const T01& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, const T00&, const T01&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, T00& a01, HHH& a02, T01& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, T00&, HHH&, T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, const T00& a01, HHH& a02, T01& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, const T00&, HHH&, T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, T00& a01, HHH& a02, const T01& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, T00&, HHH&, const T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, const T00& a01, HHH& a02, const T01& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, const T00&, HHH&, const T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, HHH& a01, T00& a02, T01& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, HHH&, T00&, T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, HHH& a01, const T00& a02, T01& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, HHH&, const T00&, T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, HHH& a01, T00& a02, const T01& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, HHH&, T00&, const T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01>
   static R apply(HHH& a00, HHH& a01, const T00& a02, const T01& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, HHH&, const T00&, const T01&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00), ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(HHH& a00, T00& a01, T01& a02, T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, T00&, T01&, T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(HHH& a00, const T00& a01, T01& a02, T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, const T00&, T01&, T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(HHH& a00, T00& a01, const T01& a02, T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, T00&, const T01&, T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(HHH& a00, T00& a01, T01& a02, const T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, T00&, T01&, const T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(HHH& a00, const T00& a01, const T01& a02, T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, const T00&, const T01&, T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(HHH& a00, const T00& a01, T01& a02, const T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, const T00&, T01&, const T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(HHH& a00, T00& a01, const T01& a02, const T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, T00&, const T01&, const T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(HHH& a00, const T00& a01, const T01& a02, const T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(HHH&, const T00&, const T01&, const T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a00)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(T00& a00, HHH& a01, T01& a02, T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, HHH&, T01&, T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(const T00& a00, HHH& a01, T01& a02, T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, HHH&, T01&, T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(T00& a00, HHH& a01, const T01& a02, T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, HHH&, const T01&, T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(T00& a00, HHH& a01, T01& a02, const T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, HHH&, T01&, const T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(const T00& a00, HHH& a01, const T01& a02, T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, HHH&, const T01&, T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(const T00& a00, HHH& a01, T01& a02, const T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, HHH&, T01&, const T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(const T00& a00, HHH& a01, const T01& a02, const T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, HHH&, const T01&, const T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a01)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(T00& a00, T01& a01, HHH& a02, T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, T01&, HHH&, T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(const T00& a00, T01& a01, HHH& a02, T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, T01&, HHH&, T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(T00& a00, const T01& a01, HHH& a02, T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, const T01&, HHH&, T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(T00& a00, T01& a01, HHH& a02, const T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, T01&, HHH&, const T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(const T00& a00, const T01& a01, HHH& a02, T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, const T01&, HHH&, T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(const T00& a00, T01& a01, HHH& a02, const T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, T01&, HHH&, const T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(T00& a00, const T01& a01, HHH& a02, const T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, const T01&, HHH&, const T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(const T00& a00, const T01& a01, HHH& a02, const T02& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, const T01&, HHH&, const T02&);
      T t(find<T>(ArgumentTraits<HHH>::id(a02)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(T00& a00, T01& a01, T02& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, T01&, T02&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(const T00& a00, T01& a01, T02& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, T01&, T02&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(T00& a00, const T01& a01, T02& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, const T01&, T02&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(T00& a00, T01& a01, const T02& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, T01&, const T02&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(const T00& a00, const T01& a01, T02& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, const T01&, T02&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(const T00& a00, T01& a01, const T02& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, T01&, const T02&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(T00& a00, const T01& a01, const T02& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(T00&, const T01&, const T02&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
   template<typename R, typename HHH, typename T00, typename T01, typename T02, typename T03>
   static R apply(const T00& a00, const T01& a01, const T02& a02, HHH& a03, typename ArgumentTraits<HHH>::type* = 0) {
      typedef R (*T)(const T00&, const T01&, const T02&, HHH&);
      T t(find<T>(ArgumentTraits<HHH>::id(a03)));
      if (!t) throw BadMultimethod();
      return t(a00, a01, a02, a03);
   };
};


//////////////////////////////////////////////////////////////////////////////
template<> struct Multimethod::ArgumentTraits<boost::any> {
   typedef boost::any type;
   static Loki::TypeInfo id(type& target) { return Loki::TypeInfo(target.type()); };
   template<typename target_t>
   static Loki::TypeInfo id() { static Loki::TypeInfo r(Loki::TypeInfo((type(target_t()).type()))); return r; };
   template<typename type_t>
   static type_t cast(type& operand) { return boost::any_cast<remove_reference<type_t>::type&>(operand); };
};

#endif