/*
 * Copyright (c) 2001-2009 XORP, Inc.
 * See the XORP LICENSE.lgpl file for licensing, conditions, and warranties
 * on use.
 *
 * This file is PROGRAMMATICALLY GENERATED.
 *
 * This instance was generated with:
 *      callback-gen.py -d -b 6 -l 15
 */

/**
 * @libdoc Callbacks
 *
 * @sect Callback Overview
 *
 * XORP is an asynchronous programming environment and as a result there
 * are many places where callbacks are useful.  Callbacks are typically
 * invoked to signify the completion or advancement of an asynchronous
 * operation.
 *
 * XORP provides a generic and flexible callback interface that utilizes
 * overloaded templatized functions for for generating callbacks
 * in conjunction with many small templatized classes. Whilst this makes
 * the syntax a little ugly, it provides a great deal of flexibility.
 *
 * XorpCallbacks are callback objects are created by the callback()
 * function which returns a reference pointer to a newly created callback
 * object.  The callback is invoked by calling dispatch(), eg.
 *
<pre>

#include "libxorp/xorp.h"
#include "libxorp/callback.hh"


static void hello_world() {
    cout << "Hello World" << endl;
}

int main() {
    // Typedef callback() return type for readability.  SimpleCallback
    // declares a XorpCallback taking 0 arguments and of return type void.
    typedef XorpCallback0<void>::RefPtr SimpleCallback;

    // Create XorpCallback object using callback()
    SimpleCallback cb = callback(hello_world);

    // Invoke callback, results in call to hello_world.
    cb->dispatch();
    return 0;
}

</pre>
 *
 * The callback() method is overloaded and can also be used to create
 * callbacks to member functions, eg.
 *
<pre>

#include "libxorp/xorp.h"
#include "libxorp/callback.hh"


class Foo {
public:
    void hello_world() {
	cout << "Foo::Hello World" << endl;
    }
};

int main() {
    typedef XorpCallback0<void>::RefPtr SimpleCallback;

    Foo f;

    // Create a callback to a member function
    SimpleCallback cb = callback(&f, &Foo::hello_world);

    // Invoke f.hello_world
    cb->dispatch();

    return 0;
}

</pre>
 *
 * In addition, to being able to invoke member functions, callbacks can
 * also store arguments to functions. eg.
 *
<pre>

#include "libxorp/xorp.h"
#include "libxorp/callback.hh"


static int sum(int x, int y) {
    cout << "sum(x = " << x << ", y = " << y << ")" << endl;
    return x + y;
}

int main() {
    // Callback to function returning "int"
    typedef XorpCallback0<int>::RefPtr NoArgCallback;

    NoArgCallback cb1 = callback(sum, 1, 2);
    cout << "cb1->dispatch() returns " << cb1->dispatch() << endl; // "3"
    cout << endl;

    // Callback to function returning int and taking an integer argument
    typedef XorpCallback1<int,int>::RefPtr OneIntArgCallback;

    OneIntArgCallback cb2 = callback(sum, 5);
    cout << "cb2->dispatch(10) returns " << cb2->dispatch(10) << endl; // 15
    cout << endl;

    cout << "cb2->dispatch(20) returns " << cb2->dispatch(20) << endl; // 25
    cout << endl;

    // Callback to function returning int and taking  2 integer arguments
    typedef XorpCallback2<int,int,int>::RefPtr TwoIntArgCallback;

    TwoIntArgCallback cb3 = callback(sum);
    cout << "cb3->dispatch() returns " << cb3->dispatch(50, -50) << endl; // 0

    return 0;
}

</pre>
 *
 * Bound arguments, as with member functions, are implemented by the
 * overloading of the callback() method.  At dispatch time, the bound
 * arguments are last arguments past to the wrappered function.  If you
 * compile and run the program you will see:
 *
<pre>
sum(x = 10, y = 5)
cb2->dispatch(10) returns 15
</pre>
 *
 * and:
 *
<pre>
sum(x = 20, y = 5)
cb2->dispatch(20) returns 25
</pre>
 *
 * for the one bound argument cases.
 *
 * @sect Declaring Callback Types
 *
 * There are a host of XorpCallbackN types.  The N denotes the number
 * of arguments that will be passed at dispatch time by the callback
 * invoker.  The template parameters to XorpCallbackN types are the
 * return value followed by the types of arguments that will be passed
 * at dispatch time.  Thus type:
 *
 * <pre>
XorpCallback1<double, int>::RefPtr
 * </pre>
 *
 * corresponds to callback object returning a double when invoked and
 * requiring an integer argument to passed at dispatch time.
 *
 * When arguments are bound to a callback they are not specified
 * in the templatized argument list. So the above declaration is good
 * for a function taking an integer argument followed by upto the
 * maximum number of bound arguments.
 *
 * Note: In this header file, support is provided for upto %d bound
 * arguments and %d dispatch arguments.
 *
 * @sect Ref Pointer Helpers
 *
 * Callback objects may be set to NULL, since they use reference pointers
 * to store the objects.  Callbacks may be unset using the ref_ptr::release()
 * method:
 *
<pre>
    cb.release();
</pre>
 * and to tested using the ref_ptr::is_empty() method:
<pre>
if (! cb.is_empty()) {
    cb->dispatch();
}
</pre>
 *
 * In many instances, the RefPtr associated with a callback on an object
 * will be stored by the object itself.  For instance, a class may own a
 * timer object and the associated timer expiry callback which is
 * a member function of the containing class.  Because the containing class
 * owns the callback object corresponding the timer callback, there is
 * never an opportunity for the callback to be dispatched on a deleted object
 * or with invalid data.
 */


#ifndef INCLUDED_FROM_CALLBACK_HH
#error "This file should be included through libxorp/callback.hh"
#endif

#ifndef __XORP_CALLBACK_HH__
#define __XORP_CALLBACK_HH__

#include "minitraits.hh"
#include "ref_ptr.hh"
#include "safe_callback_obj.hh"


#if defined(__GNUC__) && (__GNUC__ < 3)
#define callback(x...) dbg_callback(__FILE__,__LINE__,x)
#else
#define callback(...) dbg_callback(__FILE__,__LINE__,__VA_ARGS__)
#endif

void trace_dispatch_enter(const char* file, int line);
void trace_dispatch_leave();

#define record_dispatch_enter() trace_dispatch_enter( this->file(),	      						      this->line() )
#define record_dispatch_leave() trace_dispatch_leave()

///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 0 late args
//

/**
 * @short Base class for callbacks with 0 dispatch time args.
 */
template<class R>
struct XorpCallback0 {
    typedef ref_ptr<XorpCallback0> RefPtr;

    XorpCallback0(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback0() {}
    virtual R dispatch() = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 0 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R>
struct XorpFunctionCallback0B0 : public XorpCallback0<R> {
    typedef R (*F)();
    XorpFunctionCallback0B0(const char* file, int line, F f)
	: XorpCallback0<R>(file, line),
	  _f(f)
    {}
    R dispatch() {
	record_dispatch_enter();
	R r = (*_f)();
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 0 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <>
struct XorpFunctionCallback0B0<void> : public XorpCallback0<void> {
    typedef void (*F)();
    XorpFunctionCallback0B0(const char* file, int line, F f)
	: XorpCallback0<void>(file, line),
	  _f(f)
    {}
    void dispatch() {
	record_dispatch_enter();
	(*_f)();
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 0 dispatch time arguments and 0 bound arguments.
 */
template <class R>
typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line, R (*f)()) {
    return typename XorpCallback0<R>::RefPtr(new XorpFunctionCallback0B0<R>(file, line, f));
}

/**
 * @short Callback object for member methods with 0 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O>
struct XorpMemberCallback0B0 : public XorpCallback0<R> {
    typedef R (O::*M)() ;
    XorpMemberCallback0B0(const char* file, int line, O* o, M m)
	 : XorpCallback0<R>(file, line),
	  _o(o), _m(m) {}
    R dispatch() {
	record_dispatch_enter();
	R r = ((*_o).*_m)();
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 0 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O>
struct XorpMemberCallback0B0<void, O>
: public XorpCallback0<void> {
    typedef void (O::*M)() ;
    XorpMemberCallback0B0(const char* file, int line, O* o, M m)
	 : XorpCallback0<void>(file, line),
	  _o(o), _m(m) {}
    void dispatch() {
	record_dispatch_enter();
	((*_o).*_m)();
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 0 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O>
struct XorpSafeMemberCallback0B0
    : public XorpMemberCallback0B0<R, O>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback0B0<R, O>::M M;
    XorpSafeMemberCallback0B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback0B0<R, O>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback0B0() {}
    R dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback0B0<R, O>::dispatch();
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 0 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O>
struct XorpSafeMemberCallback0B0<void,O>
    : public XorpMemberCallback0B0<void, O>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback0B0<void, O>::M M;
    XorpSafeMemberCallback0B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback0B0<void, O>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback0B0() {}
    void dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback0B0<void, O>::dispatch();
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, bool B=true>
struct XorpMemberCallbackFactory0B0
{
    static XorpMemberCallback0B0<R, O>*
    make(const char* file, int line, O* o, R (O::*p)())
    {
	return new XorpSafeMemberCallback0B0<R, O>(file, line, o, p);
    }
};

template <class R, class O>
struct XorpMemberCallbackFactory0B0<R, O, false>
{
    static XorpMemberCallback0B0<R, O>*
    make(const char* file, int line, O* o, R (O::*p)())
    {
	return new XorpMemberCallback0B0<R, O>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 0 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)())
{
    return XorpMemberCallbackFactory0B0<R,  O, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 0 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)())
{
    return XorpMemberCallbackFactory0B0<R,  O, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 0 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O>
struct XorpConstMemberCallback0B0 : public XorpCallback0<R> {
    typedef R (O::*M)()  const;
    XorpConstMemberCallback0B0(const char* file, int line, O* o, M m)
	 : XorpCallback0<R>(file, line),
	  _o(o), _m(m) {}
    R dispatch() {
	record_dispatch_enter();
	R r = ((*_o).*_m)();
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 0 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O>
struct XorpConstMemberCallback0B0<void, O>
: public XorpCallback0<void> {
    typedef void (O::*M)()  const;
    XorpConstMemberCallback0B0(const char* file, int line, O* o, M m)
	 : XorpCallback0<void>(file, line),
	  _o(o), _m(m) {}
    void dispatch() {
	record_dispatch_enter();
	((*_o).*_m)();
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 0 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O>
struct XorpConstSafeMemberCallback0B0
    : public XorpConstMemberCallback0B0<R, O>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback0B0<R, O>::M M;
    XorpConstSafeMemberCallback0B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback0B0<R, O>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback0B0() {}
    R dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback0B0<R, O>::dispatch();
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 0 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O>
struct XorpConstSafeMemberCallback0B0<void,O>
    : public XorpConstMemberCallback0B0<void, O>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback0B0<void, O>::M M;
    XorpConstSafeMemberCallback0B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback0B0<void, O>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback0B0() {}
    void dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback0B0<void, O>::dispatch();
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, bool B=true>
struct XorpConstMemberCallbackFactory0B0
{
    static XorpConstMemberCallback0B0<R, O>*
    make(const char* file, int line, O* o, R (O::*p)() const)
    {
	return new XorpConstSafeMemberCallback0B0<R, O>(file, line, o, p);
    }
};

template <class R, class O>
struct XorpConstMemberCallbackFactory0B0<R, O, false>
{
    static XorpConstMemberCallback0B0<R, O>*
    make(const char* file, int line, O* o, R (O::*p)() const)
    {
	return new XorpConstMemberCallback0B0<R, O>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 0 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)() const)
{
    return XorpConstMemberCallbackFactory0B0<R,  const O, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 0 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)() const)
{
    return XorpConstMemberCallbackFactory0B0<R,  const O, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 0 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class BA1>
struct XorpFunctionCallback0B1 : public XorpCallback0<R> {
    typedef R (*F)(BA1);
    XorpFunctionCallback0B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback0<R>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch() {
	record_dispatch_enter();
	R r = (*_f)(_ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 0 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class BA1>
struct XorpFunctionCallback0B1<void, BA1> : public XorpCallback0<void> {
    typedef void (*F)(BA1);
    XorpFunctionCallback0B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback0<void>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch() {
	record_dispatch_enter();
	(*_f)(_ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 0 dispatch time arguments and 1 bound arguments.
 */
template <class R, class BA1>
typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line, R (*f)(BA1), BA1 ba1) {
    return typename XorpCallback0<R>::RefPtr(new XorpFunctionCallback0B1<R, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 0 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class BA1>
struct XorpMemberCallback0B1 : public XorpCallback0<R> {
    typedef R (O::*M)(BA1) ;
    XorpMemberCallback0B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback0<R>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch() {
	record_dispatch_enter();
	R r = ((*_o).*_m)(_ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 0 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class BA1>
struct XorpMemberCallback0B1<void, O, BA1>
: public XorpCallback0<void> {
    typedef void (O::*M)(BA1) ;
    XorpMemberCallback0B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback0<void>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch() {
	record_dispatch_enter();
	((*_o).*_m)(_ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 0 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class BA1>
struct XorpSafeMemberCallback0B1
    : public XorpMemberCallback0B1<R, O, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback0B1<R, O, BA1>::M M;
    XorpSafeMemberCallback0B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback0B1<R, O, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback0B1() {}
    R dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback0B1<R, O, BA1>::dispatch();
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 0 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class BA1>
struct XorpSafeMemberCallback0B1<void,O, BA1>
    : public XorpMemberCallback0B1<void, O, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback0B1<void, O, BA1>::M M;
    XorpSafeMemberCallback0B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback0B1<void, O, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback0B1() {}
    void dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback0B1<void, O, BA1>::dispatch();
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class BA1, bool B=true>
struct XorpMemberCallbackFactory0B1
{
    static XorpMemberCallback0B1<R, O, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback0B1<R, O, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class BA1>
struct XorpMemberCallbackFactory0B1<R, O, BA1, false>
{
    static XorpMemberCallback0B1<R, O, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(BA1), BA1 ba1)
    {
	return new XorpMemberCallback0B1<R, O, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 0 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class BA1> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory0B1<R,  O, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 0 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class BA1> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory0B1<R,  O, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 0 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class BA1>
struct XorpConstMemberCallback0B1 : public XorpCallback0<R> {
    typedef R (O::*M)(BA1)  const;
    XorpConstMemberCallback0B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback0<R>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch() {
	record_dispatch_enter();
	R r = ((*_o).*_m)(_ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 0 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class BA1>
struct XorpConstMemberCallback0B1<void, O, BA1>
: public XorpCallback0<void> {
    typedef void (O::*M)(BA1)  const;
    XorpConstMemberCallback0B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback0<void>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch() {
	record_dispatch_enter();
	((*_o).*_m)(_ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 0 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class BA1>
struct XorpConstSafeMemberCallback0B1
    : public XorpConstMemberCallback0B1<R, O, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback0B1<R, O, BA1>::M M;
    XorpConstSafeMemberCallback0B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback0B1<R, O, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback0B1() {}
    R dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback0B1<R, O, BA1>::dispatch();
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 0 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class BA1>
struct XorpConstSafeMemberCallback0B1<void,O, BA1>
    : public XorpConstMemberCallback0B1<void, O, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback0B1<void, O, BA1>::M M;
    XorpConstSafeMemberCallback0B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback0B1<void, O, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback0B1() {}
    void dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback0B1<void, O, BA1>::dispatch();
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory0B1
{
    static XorpConstMemberCallback0B1<R, O, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback0B1<R, O, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class BA1>
struct XorpConstMemberCallbackFactory0B1<R, O, BA1, false>
{
    static XorpConstMemberCallback0B1<R, O, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback0B1<R, O, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 0 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class BA1> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory0B1<R,  const O, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 0 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class BA1> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory0B1<R,  const O, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 0 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class BA1, class BA2>
struct XorpFunctionCallback0B2 : public XorpCallback0<R> {
    typedef R (*F)(BA1, BA2);
    XorpFunctionCallback0B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback0<R>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch() {
	record_dispatch_enter();
	R r = (*_f)(_ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 0 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class BA1, class BA2>
struct XorpFunctionCallback0B2<void, BA1, BA2> : public XorpCallback0<void> {
    typedef void (*F)(BA1, BA2);
    XorpFunctionCallback0B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback0<void>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch() {
	record_dispatch_enter();
	(*_f)(_ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 0 dispatch time arguments and 2 bound arguments.
 */
template <class R, class BA1, class BA2>
typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line, R (*f)(BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback0<R>::RefPtr(new XorpFunctionCallback0B2<R, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 0 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2>
struct XorpMemberCallback0B2 : public XorpCallback0<R> {
    typedef R (O::*M)(BA1, BA2) ;
    XorpMemberCallback0B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback0<R>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch() {
	record_dispatch_enter();
	R r = ((*_o).*_m)(_ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 0 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class BA1, class BA2>
struct XorpMemberCallback0B2<void, O, BA1, BA2>
: public XorpCallback0<void> {
    typedef void (O::*M)(BA1, BA2) ;
    XorpMemberCallback0B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback0<void>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch() {
	record_dispatch_enter();
	((*_o).*_m)(_ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 0 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2>
struct XorpSafeMemberCallback0B2
    : public XorpMemberCallback0B2<R, O, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback0B2<R, O, BA1, BA2>::M M;
    XorpSafeMemberCallback0B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback0B2<R, O, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback0B2() {}
    R dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback0B2<R, O, BA1, BA2>::dispatch();
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 0 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class BA1, class BA2>
struct XorpSafeMemberCallback0B2<void,O, BA1, BA2>
    : public XorpMemberCallback0B2<void, O, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback0B2<void, O, BA1, BA2>::M M;
    XorpSafeMemberCallback0B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback0B2<void, O, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback0B2() {}
    void dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback0B2<void, O, BA1, BA2>::dispatch();
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory0B2
{
    static XorpMemberCallback0B2<R, O, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback0B2<R, O, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class BA1, class BA2>
struct XorpMemberCallbackFactory0B2<R, O, BA1, BA2, false>
{
    static XorpMemberCallback0B2<R, O, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback0B2<R, O, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 0 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class BA1, class BA2> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory0B2<R,  O, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 0 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class BA1, class BA2> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory0B2<R,  O, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 0 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2>
struct XorpConstMemberCallback0B2 : public XorpCallback0<R> {
    typedef R (O::*M)(BA1, BA2)  const;
    XorpConstMemberCallback0B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback0<R>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch() {
	record_dispatch_enter();
	R r = ((*_o).*_m)(_ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 0 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class BA1, class BA2>
struct XorpConstMemberCallback0B2<void, O, BA1, BA2>
: public XorpCallback0<void> {
    typedef void (O::*M)(BA1, BA2)  const;
    XorpConstMemberCallback0B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback0<void>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch() {
	record_dispatch_enter();
	((*_o).*_m)(_ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 0 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2>
struct XorpConstSafeMemberCallback0B2
    : public XorpConstMemberCallback0B2<R, O, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback0B2<R, O, BA1, BA2>::M M;
    XorpConstSafeMemberCallback0B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback0B2<R, O, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback0B2() {}
    R dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback0B2<R, O, BA1, BA2>::dispatch();
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 0 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class BA1, class BA2>
struct XorpConstSafeMemberCallback0B2<void,O, BA1, BA2>
    : public XorpConstMemberCallback0B2<void, O, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback0B2<void, O, BA1, BA2>::M M;
    XorpConstSafeMemberCallback0B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback0B2<void, O, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback0B2() {}
    void dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback0B2<void, O, BA1, BA2>::dispatch();
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory0B2
{
    static XorpConstMemberCallback0B2<R, O, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback0B2<R, O, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class BA1, class BA2>
struct XorpConstMemberCallbackFactory0B2<R, O, BA1, BA2, false>
{
    static XorpConstMemberCallback0B2<R, O, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback0B2<R, O, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 0 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class BA1, class BA2> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory0B2<R,  const O, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 0 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class BA1, class BA2> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory0B2<R,  const O, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 0 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class BA1, class BA2, class BA3>
struct XorpFunctionCallback0B3 : public XorpCallback0<R> {
    typedef R (*F)(BA1, BA2, BA3);
    XorpFunctionCallback0B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback0<R>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch() {
	record_dispatch_enter();
	R r = (*_f)(_ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 0 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class BA1, class BA2, class BA3>
struct XorpFunctionCallback0B3<void, BA1, BA2, BA3> : public XorpCallback0<void> {
    typedef void (*F)(BA1, BA2, BA3);
    XorpFunctionCallback0B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback0<void>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch() {
	record_dispatch_enter();
	(*_f)(_ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 0 dispatch time arguments and 3 bound arguments.
 */
template <class R, class BA1, class BA2, class BA3>
typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line, R (*f)(BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback0<R>::RefPtr(new XorpFunctionCallback0B3<R, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 0 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3>
struct XorpMemberCallback0B3 : public XorpCallback0<R> {
    typedef R (O::*M)(BA1, BA2, BA3) ;
    XorpMemberCallback0B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback0<R>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch() {
	record_dispatch_enter();
	R r = ((*_o).*_m)(_ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 0 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3>
struct XorpMemberCallback0B3<void, O, BA1, BA2, BA3>
: public XorpCallback0<void> {
    typedef void (O::*M)(BA1, BA2, BA3) ;
    XorpMemberCallback0B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback0<void>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch() {
	record_dispatch_enter();
	((*_o).*_m)(_ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 0 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback0B3
    : public XorpMemberCallback0B3<R, O, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback0B3<R, O, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback0B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback0B3<R, O, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback0B3() {}
    R dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback0B3<R, O, BA1, BA2, BA3>::dispatch();
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 0 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback0B3<void,O, BA1, BA2, BA3>
    : public XorpMemberCallback0B3<void, O, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback0B3<void, O, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback0B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback0B3<void, O, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback0B3() {}
    void dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback0B3<void, O, BA1, BA2, BA3>::dispatch();
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory0B3
{
    static XorpMemberCallback0B3<R, O, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback0B3<R, O, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory0B3<R, O, BA1, BA2, BA3, false>
{
    static XorpMemberCallback0B3<R, O, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback0B3<R, O, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 0 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory0B3<R,  O, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 0 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory0B3<R,  O, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 0 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback0B3 : public XorpCallback0<R> {
    typedef R (O::*M)(BA1, BA2, BA3)  const;
    XorpConstMemberCallback0B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback0<R>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch() {
	record_dispatch_enter();
	R r = ((*_o).*_m)(_ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 0 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback0B3<void, O, BA1, BA2, BA3>
: public XorpCallback0<void> {
    typedef void (O::*M)(BA1, BA2, BA3)  const;
    XorpConstMemberCallback0B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback0<void>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch() {
	record_dispatch_enter();
	((*_o).*_m)(_ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 0 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback0B3
    : public XorpConstMemberCallback0B3<R, O, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback0B3<R, O, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback0B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback0B3<R, O, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback0B3() {}
    R dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback0B3<R, O, BA1, BA2, BA3>::dispatch();
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 0 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback0B3<void,O, BA1, BA2, BA3>
    : public XorpConstMemberCallback0B3<void, O, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback0B3<void, O, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback0B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback0B3<void, O, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback0B3() {}
    void dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback0B3<void, O, BA1, BA2, BA3>::dispatch();
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory0B3
{
    static XorpConstMemberCallback0B3<R, O, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback0B3<R, O, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory0B3<R, O, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback0B3<R, O, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback0B3<R, O, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 0 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory0B3<R,  const O, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 0 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory0B3<R,  const O, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 0 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback0B4 : public XorpCallback0<R> {
    typedef R (*F)(BA1, BA2, BA3, BA4);
    XorpFunctionCallback0B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback0<R>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch() {
	record_dispatch_enter();
	R r = (*_f)(_ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 0 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback0B4<void, BA1, BA2, BA3, BA4> : public XorpCallback0<void> {
    typedef void (*F)(BA1, BA2, BA3, BA4);
    XorpFunctionCallback0B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback0<void>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch() {
	record_dispatch_enter();
	(*_f)(_ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 0 dispatch time arguments and 4 bound arguments.
 */
template <class R, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line, R (*f)(BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback0<R>::RefPtr(new XorpFunctionCallback0B4<R, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 0 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback0B4 : public XorpCallback0<R> {
    typedef R (O::*M)(BA1, BA2, BA3, BA4) ;
    XorpMemberCallback0B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback0<R>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch() {
	record_dispatch_enter();
	R r = ((*_o).*_m)(_ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 0 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback0B4<void, O, BA1, BA2, BA3, BA4>
: public XorpCallback0<void> {
    typedef void (O::*M)(BA1, BA2, BA3, BA4) ;
    XorpMemberCallback0B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback0<void>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch() {
	record_dispatch_enter();
	((*_o).*_m)(_ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 0 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback0B4
    : public XorpMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback0B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback0B4() {}
    R dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>::dispatch();
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 0 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback0B4<void,O, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback0B4<void, O, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback0B4<void, O, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback0B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback0B4<void, O, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback0B4() {}
    void dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback0B4<void, O, BA1, BA2, BA3, BA4>::dispatch();
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory0B4
{
    static XorpMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory0B4<R, O, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 0 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory0B4<R,  O, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 0 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory0B4<R,  O, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 0 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback0B4 : public XorpCallback0<R> {
    typedef R (O::*M)(BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback0B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback0<R>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch() {
	record_dispatch_enter();
	R r = ((*_o).*_m)(_ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 0 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback0B4<void, O, BA1, BA2, BA3, BA4>
: public XorpCallback0<void> {
    typedef void (O::*M)(BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback0B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback0<void>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch() {
	record_dispatch_enter();
	((*_o).*_m)(_ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 0 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback0B4
    : public XorpConstMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback0B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback0B4() {}
    R dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>::dispatch();
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 0 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback0B4<void,O, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback0B4<void, O, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback0B4<void, O, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback0B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback0B4<void, O, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback0B4() {}
    void dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback0B4<void, O, BA1, BA2, BA3, BA4>::dispatch();
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory0B4
{
    static XorpConstMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory0B4<R, O, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback0B4<R, O, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 0 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory0B4<R,  const O, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 0 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory0B4<R,  const O, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 0 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback0B5 : public XorpCallback0<R> {
    typedef R (*F)(BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback0B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback0<R>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch() {
	record_dispatch_enter();
	R r = (*_f)(_ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 0 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback0B5<void, BA1, BA2, BA3, BA4, BA5> : public XorpCallback0<void> {
    typedef void (*F)(BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback0B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback0<void>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch() {
	record_dispatch_enter();
	(*_f)(_ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 0 dispatch time arguments and 5 bound arguments.
 */
template <class R, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line, R (*f)(BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback0<R>::RefPtr(new XorpFunctionCallback0B5<R, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 0 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback0B5 : public XorpCallback0<R> {
    typedef R (O::*M)(BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback0B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback0<R>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch() {
	record_dispatch_enter();
	R r = ((*_o).*_m)(_ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 0 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback0B5<void, O, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback0<void> {
    typedef void (O::*M)(BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback0B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback0<void>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch() {
	record_dispatch_enter();
	((*_o).*_m)(_ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 0 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback0B5
    : public XorpMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback0B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback0B5() {}
    R dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>::dispatch();
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 0 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback0B5<void,O, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback0B5<void, O, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback0B5<void, O, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback0B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback0B5<void, O, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback0B5() {}
    void dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback0B5<void, O, BA1, BA2, BA3, BA4, BA5>::dispatch();
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory0B5
{
    static XorpMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory0B5<R, O, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 0 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory0B5<R,  O, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 0 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory0B5<R,  O, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 0 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback0B5 : public XorpCallback0<R> {
    typedef R (O::*M)(BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback0B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback0<R>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch() {
	record_dispatch_enter();
	R r = ((*_o).*_m)(_ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 0 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback0B5<void, O, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback0<void> {
    typedef void (O::*M)(BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback0B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback0<void>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch() {
	record_dispatch_enter();
	((*_o).*_m)(_ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 0 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback0B5
    : public XorpConstMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback0B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback0B5() {}
    R dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>::dispatch();
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 0 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback0B5<void,O, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback0B5<void, O, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback0B5<void, O, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback0B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback0B5<void, O, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback0B5() {}
    void dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback0B5<void, O, BA1, BA2, BA3, BA4, BA5>::dispatch();
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory0B5
{
    static XorpConstMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory0B5<R, O, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback0B5<R, O, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 0 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory0B5<R,  const O, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 0 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory0B5<R,  const O, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 0 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback0B6 : public XorpCallback0<R> {
    typedef R (*F)(BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback0B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback0<R>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch() {
	record_dispatch_enter();
	R r = (*_f)(_ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 0 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback0B6<void, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback0<void> {
    typedef void (*F)(BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback0B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback0<void>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch() {
	record_dispatch_enter();
	(*_f)(_ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 0 dispatch time arguments and 6 bound arguments.
 */
template <class R, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line, R (*f)(BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback0<R>::RefPtr(new XorpFunctionCallback0B6<R, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 0 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback0B6 : public XorpCallback0<R> {
    typedef R (O::*M)(BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback0B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback0<R>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch() {
	record_dispatch_enter();
	R r = ((*_o).*_m)(_ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 0 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback0B6<void, O, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback0<void> {
    typedef void (O::*M)(BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback0B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback0<void>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch() {
	record_dispatch_enter();
	((*_o).*_m)(_ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 0 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback0B6
    : public XorpMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback0B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback0B6() {}
    R dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch();
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 0 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback0B6<void,O, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback0B6<void, O, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback0B6<void, O, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback0B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback0B6<void, O, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback0B6() {}
    void dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback0B6<void, O, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch();
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory0B6
{
    static XorpMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 0 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory0B6<R,  O, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 0 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory0B6<R,  O, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 0 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback0B6 : public XorpCallback0<R> {
    typedef R (O::*M)(BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback0B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback0<R>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch() {
	record_dispatch_enter();
	R r = ((*_o).*_m)(_ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 0 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback0B6<void, O, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback0<void> {
    typedef void (O::*M)(BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback0B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback0<void>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch() {
	record_dispatch_enter();
	((*_o).*_m)(_ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 0 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback0B6
    : public XorpConstMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback0B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback0B6() {}
    R dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch();
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 0 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback0B6<void,O, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback0B6<void, O, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback0B6<void, O, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback0B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback0B6<void, O, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback0B6() {}
    void dispatch() {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback0B6<void, O, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch();
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory0B6
{
    static XorpConstMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback0B6<R, O, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 0 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory0B6<R,  const O, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 0 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback0<R>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory0B6<R,  const O, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 1 late args
//

/**
 * @short Base class for callbacks with 1 dispatch time args.
 */
template<class R, class A1>
struct XorpCallback1 {
    typedef ref_ptr<XorpCallback1> RefPtr;

    XorpCallback1(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback1() {}
    virtual R dispatch(A1) = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 1 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class A1>
struct XorpFunctionCallback1B0 : public XorpCallback1<R, A1> {
    typedef R (*F)(A1);
    XorpFunctionCallback1B0(const char* file, int line, F f)
	: XorpCallback1<R, A1>(file, line),
	  _f(f)
    {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = (*_f)(a1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 1 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class A1>
struct XorpFunctionCallback1B0<void, A1> : public XorpCallback1<void, A1> {
    typedef void (*F)(A1);
    XorpFunctionCallback1B0(const char* file, int line, F f)
	: XorpCallback1<void, A1>(file, line),
	  _f(f)
    {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	(*_f)(a1);
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 1 dispatch time arguments and 0 bound arguments.
 */
template <class R, class A1>
typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1)) {
    return typename XorpCallback1<R, A1>::RefPtr(new XorpFunctionCallback1B0<R, A1>(file, line, f));
}

/**
 * @short Callback object for member methods with 1 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1>
struct XorpMemberCallback1B0 : public XorpCallback1<R, A1> {
    typedef R (O::*M)(A1) ;
    XorpMemberCallback1B0(const char* file, int line, O* o, M m)
	 : XorpCallback1<R, A1>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 1 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1>
struct XorpMemberCallback1B0<void, O, A1>
: public XorpCallback1<void, A1> {
    typedef void (O::*M)(A1) ;
    XorpMemberCallback1B0(const char* file, int line, O* o, M m)
	 : XorpCallback1<void, A1>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	((*_o).*_m)(a1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 1 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1>
struct XorpSafeMemberCallback1B0
    : public XorpMemberCallback1B0<R, O, A1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback1B0<R, O, A1>::M M;
    XorpSafeMemberCallback1B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback1B0<R, O, A1>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback1B0() {}
    R dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback1B0<R, O, A1>::dispatch(a1);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 1 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1>
struct XorpSafeMemberCallback1B0<void,O, A1>
    : public XorpMemberCallback1B0<void, O, A1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback1B0<void, O, A1>::M M;
    XorpSafeMemberCallback1B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback1B0<void, O, A1>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback1B0() {}
    void dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback1B0<void, O, A1>::dispatch(a1);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, bool B=true>
struct XorpMemberCallbackFactory1B0
{
    static XorpMemberCallback1B0<R, O, A1>*
    make(const char* file, int line, O* o, R (O::*p)(A1))
    {
	return new XorpSafeMemberCallback1B0<R, O, A1>(file, line, o, p);
    }
};

template <class R, class O, class A1>
struct XorpMemberCallbackFactory1B0<R, O, A1, false>
{
    static XorpMemberCallback1B0<R, O, A1>*
    make(const char* file, int line, O* o, R (O::*p)(A1))
    {
	return new XorpMemberCallback1B0<R, O, A1>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 1 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1))
{
    return XorpMemberCallbackFactory1B0<R,  O, A1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 1 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1))
{
    return XorpMemberCallbackFactory1B0<R,  O, A1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 1 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1>
struct XorpConstMemberCallback1B0 : public XorpCallback1<R, A1> {
    typedef R (O::*M)(A1)  const;
    XorpConstMemberCallback1B0(const char* file, int line, O* o, M m)
	 : XorpCallback1<R, A1>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 1 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1>
struct XorpConstMemberCallback1B0<void, O, A1>
: public XorpCallback1<void, A1> {
    typedef void (O::*M)(A1)  const;
    XorpConstMemberCallback1B0(const char* file, int line, O* o, M m)
	 : XorpCallback1<void, A1>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	((*_o).*_m)(a1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 1 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1>
struct XorpConstSafeMemberCallback1B0
    : public XorpConstMemberCallback1B0<R, O, A1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback1B0<R, O, A1>::M M;
    XorpConstSafeMemberCallback1B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback1B0<R, O, A1>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback1B0() {}
    R dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback1B0<R, O, A1>::dispatch(a1);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 1 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1>
struct XorpConstSafeMemberCallback1B0<void,O, A1>
    : public XorpConstMemberCallback1B0<void, O, A1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback1B0<void, O, A1>::M M;
    XorpConstSafeMemberCallback1B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback1B0<void, O, A1>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback1B0() {}
    void dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback1B0<void, O, A1>::dispatch(a1);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, bool B=true>
struct XorpConstMemberCallbackFactory1B0
{
    static XorpConstMemberCallback1B0<R, O, A1>*
    make(const char* file, int line, O* o, R (O::*p)(A1) const)
    {
	return new XorpConstSafeMemberCallback1B0<R, O, A1>(file, line, o, p);
    }
};

template <class R, class O, class A1>
struct XorpConstMemberCallbackFactory1B0<R, O, A1, false>
{
    static XorpConstMemberCallback1B0<R, O, A1>*
    make(const char* file, int line, O* o, R (O::*p)(A1) const)
    {
	return new XorpConstMemberCallback1B0<R, O, A1>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 1 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1) const)
{
    return XorpConstMemberCallbackFactory1B0<R,  const O, A1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 1 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1) const)
{
    return XorpConstMemberCallbackFactory1B0<R,  const O, A1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 1 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class A1, class BA1>
struct XorpFunctionCallback1B1 : public XorpCallback1<R, A1> {
    typedef R (*F)(A1, BA1);
    XorpFunctionCallback1B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback1<R, A1>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = (*_f)(a1, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 1 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class A1, class BA1>
struct XorpFunctionCallback1B1<void, A1, BA1> : public XorpCallback1<void, A1> {
    typedef void (*F)(A1, BA1);
    XorpFunctionCallback1B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback1<void, A1>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	(*_f)(a1, _ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 1 dispatch time arguments and 1 bound arguments.
 */
template <class R, class A1, class BA1>
typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, BA1), BA1 ba1) {
    return typename XorpCallback1<R, A1>::RefPtr(new XorpFunctionCallback1B1<R, A1, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 1 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1>
struct XorpMemberCallback1B1 : public XorpCallback1<R, A1> {
    typedef R (O::*M)(A1, BA1) ;
    XorpMemberCallback1B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback1<R, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 1 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class BA1>
struct XorpMemberCallback1B1<void, O, A1, BA1>
: public XorpCallback1<void, A1> {
    typedef void (O::*M)(A1, BA1) ;
    XorpMemberCallback1B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback1<void, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	((*_o).*_m)(a1, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 1 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1>
struct XorpSafeMemberCallback1B1
    : public XorpMemberCallback1B1<R, O, A1, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback1B1<R, O, A1, BA1>::M M;
    XorpSafeMemberCallback1B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback1B1<R, O, A1, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback1B1() {}
    R dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback1B1<R, O, A1, BA1>::dispatch(a1);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 1 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class BA1>
struct XorpSafeMemberCallback1B1<void,O, A1, BA1>
    : public XorpMemberCallback1B1<void, O, A1, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback1B1<void, O, A1, BA1>::M M;
    XorpSafeMemberCallback1B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback1B1<void, O, A1, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback1B1() {}
    void dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback1B1<void, O, A1, BA1>::dispatch(a1);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class BA1, bool B=true>
struct XorpMemberCallbackFactory1B1
{
    static XorpMemberCallback1B1<R, O, A1, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback1B1<R, O, A1, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class BA1>
struct XorpMemberCallbackFactory1B1<R, O, A1, BA1, false>
{
    static XorpMemberCallback1B1<R, O, A1, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1), BA1 ba1)
    {
	return new XorpMemberCallback1B1<R, O, A1, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 1 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class BA1> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory1B1<R,  O, A1, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 1 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class BA1> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory1B1<R,  O, A1, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 1 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1>
struct XorpConstMemberCallback1B1 : public XorpCallback1<R, A1> {
    typedef R (O::*M)(A1, BA1)  const;
    XorpConstMemberCallback1B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback1<R, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 1 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class BA1>
struct XorpConstMemberCallback1B1<void, O, A1, BA1>
: public XorpCallback1<void, A1> {
    typedef void (O::*M)(A1, BA1)  const;
    XorpConstMemberCallback1B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback1<void, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	((*_o).*_m)(a1, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 1 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1>
struct XorpConstSafeMemberCallback1B1
    : public XorpConstMemberCallback1B1<R, O, A1, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback1B1<R, O, A1, BA1>::M M;
    XorpConstSafeMemberCallback1B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback1B1<R, O, A1, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback1B1() {}
    R dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback1B1<R, O, A1, BA1>::dispatch(a1);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 1 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class BA1>
struct XorpConstSafeMemberCallback1B1<void,O, A1, BA1>
    : public XorpConstMemberCallback1B1<void, O, A1, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback1B1<void, O, A1, BA1>::M M;
    XorpConstSafeMemberCallback1B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback1B1<void, O, A1, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback1B1() {}
    void dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback1B1<void, O, A1, BA1>::dispatch(a1);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory1B1
{
    static XorpConstMemberCallback1B1<R, O, A1, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback1B1<R, O, A1, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class BA1>
struct XorpConstMemberCallbackFactory1B1<R, O, A1, BA1, false>
{
    static XorpConstMemberCallback1B1<R, O, A1, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback1B1<R, O, A1, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 1 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class BA1> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory1B1<R,  const O, A1, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 1 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class BA1> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory1B1<R,  const O, A1, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 1 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class A1, class BA1, class BA2>
struct XorpFunctionCallback1B2 : public XorpCallback1<R, A1> {
    typedef R (*F)(A1, BA1, BA2);
    XorpFunctionCallback1B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback1<R, A1>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = (*_f)(a1, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 1 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class A1, class BA1, class BA2>
struct XorpFunctionCallback1B2<void, A1, BA1, BA2> : public XorpCallback1<void, A1> {
    typedef void (*F)(A1, BA1, BA2);
    XorpFunctionCallback1B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback1<void, A1>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	(*_f)(a1, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 1 dispatch time arguments and 2 bound arguments.
 */
template <class R, class A1, class BA1, class BA2>
typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback1<R, A1>::RefPtr(new XorpFunctionCallback1B2<R, A1, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 1 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2>
struct XorpMemberCallback1B2 : public XorpCallback1<R, A1> {
    typedef R (O::*M)(A1, BA1, BA2) ;
    XorpMemberCallback1B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback1<R, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 1 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2>
struct XorpMemberCallback1B2<void, O, A1, BA1, BA2>
: public XorpCallback1<void, A1> {
    typedef void (O::*M)(A1, BA1, BA2) ;
    XorpMemberCallback1B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback1<void, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	((*_o).*_m)(a1, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 1 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2>
struct XorpSafeMemberCallback1B2
    : public XorpMemberCallback1B2<R, O, A1, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback1B2<R, O, A1, BA1, BA2>::M M;
    XorpSafeMemberCallback1B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback1B2<R, O, A1, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback1B2() {}
    R dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback1B2<R, O, A1, BA1, BA2>::dispatch(a1);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 1 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2>
struct XorpSafeMemberCallback1B2<void,O, A1, BA1, BA2>
    : public XorpMemberCallback1B2<void, O, A1, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback1B2<void, O, A1, BA1, BA2>::M M;
    XorpSafeMemberCallback1B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback1B2<void, O, A1, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback1B2() {}
    void dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback1B2<void, O, A1, BA1, BA2>::dispatch(a1);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory1B2
{
    static XorpMemberCallback1B2<R, O, A1, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback1B2<R, O, A1, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class BA1, class BA2>
struct XorpMemberCallbackFactory1B2<R, O, A1, BA1, BA2, false>
{
    static XorpMemberCallback1B2<R, O, A1, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback1B2<R, O, A1, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 1 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory1B2<R,  O, A1, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 1 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory1B2<R,  O, A1, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 1 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2>
struct XorpConstMemberCallback1B2 : public XorpCallback1<R, A1> {
    typedef R (O::*M)(A1, BA1, BA2)  const;
    XorpConstMemberCallback1B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback1<R, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 1 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2>
struct XorpConstMemberCallback1B2<void, O, A1, BA1, BA2>
: public XorpCallback1<void, A1> {
    typedef void (O::*M)(A1, BA1, BA2)  const;
    XorpConstMemberCallback1B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback1<void, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	((*_o).*_m)(a1, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 1 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2>
struct XorpConstSafeMemberCallback1B2
    : public XorpConstMemberCallback1B2<R, O, A1, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback1B2<R, O, A1, BA1, BA2>::M M;
    XorpConstSafeMemberCallback1B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback1B2<R, O, A1, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback1B2() {}
    R dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback1B2<R, O, A1, BA1, BA2>::dispatch(a1);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 1 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2>
struct XorpConstSafeMemberCallback1B2<void,O, A1, BA1, BA2>
    : public XorpConstMemberCallback1B2<void, O, A1, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback1B2<void, O, A1, BA1, BA2>::M M;
    XorpConstSafeMemberCallback1B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback1B2<void, O, A1, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback1B2() {}
    void dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback1B2<void, O, A1, BA1, BA2>::dispatch(a1);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory1B2
{
    static XorpConstMemberCallback1B2<R, O, A1, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback1B2<R, O, A1, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class BA1, class BA2>
struct XorpConstMemberCallbackFactory1B2<R, O, A1, BA1, BA2, false>
{
    static XorpConstMemberCallback1B2<R, O, A1, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback1B2<R, O, A1, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 1 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory1B2<R,  const O, A1, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 1 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory1B2<R,  const O, A1, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 1 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class A1, class BA1, class BA2, class BA3>
struct XorpFunctionCallback1B3 : public XorpCallback1<R, A1> {
    typedef R (*F)(A1, BA1, BA2, BA3);
    XorpFunctionCallback1B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback1<R, A1>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = (*_f)(a1, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 1 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class A1, class BA1, class BA2, class BA3>
struct XorpFunctionCallback1B3<void, A1, BA1, BA2, BA3> : public XorpCallback1<void, A1> {
    typedef void (*F)(A1, BA1, BA2, BA3);
    XorpFunctionCallback1B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback1<void, A1>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	(*_f)(a1, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 1 dispatch time arguments and 3 bound arguments.
 */
template <class R, class A1, class BA1, class BA2, class BA3>
typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback1<R, A1>::RefPtr(new XorpFunctionCallback1B3<R, A1, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 1 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3>
struct XorpMemberCallback1B3 : public XorpCallback1<R, A1> {
    typedef R (O::*M)(A1, BA1, BA2, BA3) ;
    XorpMemberCallback1B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback1<R, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 1 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3>
struct XorpMemberCallback1B3<void, O, A1, BA1, BA2, BA3>
: public XorpCallback1<void, A1> {
    typedef void (O::*M)(A1, BA1, BA2, BA3) ;
    XorpMemberCallback1B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback1<void, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	((*_o).*_m)(a1, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 1 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback1B3
    : public XorpMemberCallback1B3<R, O, A1, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback1B3<R, O, A1, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback1B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback1B3<R, O, A1, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback1B3() {}
    R dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback1B3<R, O, A1, BA1, BA2, BA3>::dispatch(a1);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 1 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback1B3<void,O, A1, BA1, BA2, BA3>
    : public XorpMemberCallback1B3<void, O, A1, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback1B3<void, O, A1, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback1B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback1B3<void, O, A1, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback1B3() {}
    void dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback1B3<void, O, A1, BA1, BA2, BA3>::dispatch(a1);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory1B3
{
    static XorpMemberCallback1B3<R, O, A1, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback1B3<R, O, A1, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory1B3<R, O, A1, BA1, BA2, BA3, false>
{
    static XorpMemberCallback1B3<R, O, A1, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback1B3<R, O, A1, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 1 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory1B3<R,  O, A1, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 1 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory1B3<R,  O, A1, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 1 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback1B3 : public XorpCallback1<R, A1> {
    typedef R (O::*M)(A1, BA1, BA2, BA3)  const;
    XorpConstMemberCallback1B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback1<R, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 1 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback1B3<void, O, A1, BA1, BA2, BA3>
: public XorpCallback1<void, A1> {
    typedef void (O::*M)(A1, BA1, BA2, BA3)  const;
    XorpConstMemberCallback1B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback1<void, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	((*_o).*_m)(a1, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 1 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback1B3
    : public XorpConstMemberCallback1B3<R, O, A1, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback1B3<R, O, A1, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback1B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback1B3<R, O, A1, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback1B3() {}
    R dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback1B3<R, O, A1, BA1, BA2, BA3>::dispatch(a1);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 1 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback1B3<void,O, A1, BA1, BA2, BA3>
    : public XorpConstMemberCallback1B3<void, O, A1, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback1B3<void, O, A1, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback1B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback1B3<void, O, A1, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback1B3() {}
    void dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback1B3<void, O, A1, BA1, BA2, BA3>::dispatch(a1);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory1B3
{
    static XorpConstMemberCallback1B3<R, O, A1, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback1B3<R, O, A1, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory1B3<R, O, A1, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback1B3<R, O, A1, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback1B3<R, O, A1, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 1 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory1B3<R,  const O, A1, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 1 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory1B3<R,  const O, A1, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 1 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class A1, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback1B4 : public XorpCallback1<R, A1> {
    typedef R (*F)(A1, BA1, BA2, BA3, BA4);
    XorpFunctionCallback1B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback1<R, A1>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = (*_f)(a1, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 1 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class A1, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback1B4<void, A1, BA1, BA2, BA3, BA4> : public XorpCallback1<void, A1> {
    typedef void (*F)(A1, BA1, BA2, BA3, BA4);
    XorpFunctionCallback1B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback1<void, A1>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	(*_f)(a1, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 1 dispatch time arguments and 4 bound arguments.
 */
template <class R, class A1, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback1<R, A1>::RefPtr(new XorpFunctionCallback1B4<R, A1, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 1 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback1B4 : public XorpCallback1<R, A1> {
    typedef R (O::*M)(A1, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback1B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback1<R, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 1 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback1B4<void, O, A1, BA1, BA2, BA3, BA4>
: public XorpCallback1<void, A1> {
    typedef void (O::*M)(A1, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback1B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback1<void, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	((*_o).*_m)(a1, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 1 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback1B4
    : public XorpMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback1B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback1B4() {}
    R dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>::dispatch(a1);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 1 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback1B4<void,O, A1, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback1B4<void, O, A1, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback1B4<void, O, A1, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback1B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback1B4<void, O, A1, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback1B4() {}
    void dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback1B4<void, O, A1, BA1, BA2, BA3, BA4>::dispatch(a1);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory1B4
{
    static XorpMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory1B4<R, O, A1, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 1 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory1B4<R,  O, A1, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 1 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory1B4<R,  O, A1, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 1 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback1B4 : public XorpCallback1<R, A1> {
    typedef R (O::*M)(A1, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback1B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback1<R, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 1 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback1B4<void, O, A1, BA1, BA2, BA3, BA4>
: public XorpCallback1<void, A1> {
    typedef void (O::*M)(A1, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback1B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback1<void, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	((*_o).*_m)(a1, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 1 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback1B4
    : public XorpConstMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback1B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback1B4() {}
    R dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>::dispatch(a1);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 1 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback1B4<void,O, A1, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback1B4<void, O, A1, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback1B4<void, O, A1, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback1B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback1B4<void, O, A1, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback1B4() {}
    void dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback1B4<void, O, A1, BA1, BA2, BA3, BA4>::dispatch(a1);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory1B4
{
    static XorpConstMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory1B4<R, O, A1, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback1B4<R, O, A1, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 1 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory1B4<R,  const O, A1, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 1 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory1B4<R,  const O, A1, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 1 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class A1, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback1B5 : public XorpCallback1<R, A1> {
    typedef R (*F)(A1, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback1B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback1<R, A1>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = (*_f)(a1, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 1 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class A1, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback1B5<void, A1, BA1, BA2, BA3, BA4, BA5> : public XorpCallback1<void, A1> {
    typedef void (*F)(A1, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback1B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback1<void, A1>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	(*_f)(a1, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 1 dispatch time arguments and 5 bound arguments.
 */
template <class R, class A1, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback1<R, A1>::RefPtr(new XorpFunctionCallback1B5<R, A1, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 1 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback1B5 : public XorpCallback1<R, A1> {
    typedef R (O::*M)(A1, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback1B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback1<R, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 1 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback1B5<void, O, A1, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback1<void, A1> {
    typedef void (O::*M)(A1, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback1B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback1<void, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	((*_o).*_m)(a1, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 1 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback1B5
    : public XorpMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback1B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback1B5() {}
    R dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>::dispatch(a1);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 1 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback1B5<void,O, A1, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback1B5<void, O, A1, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback1B5<void, O, A1, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback1B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback1B5<void, O, A1, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback1B5() {}
    void dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback1B5<void, O, A1, BA1, BA2, BA3, BA4, BA5>::dispatch(a1);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory1B5
{
    static XorpMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 1 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory1B5<R,  O, A1, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 1 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory1B5<R,  O, A1, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 1 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback1B5 : public XorpCallback1<R, A1> {
    typedef R (O::*M)(A1, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback1B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback1<R, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 1 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback1B5<void, O, A1, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback1<void, A1> {
    typedef void (O::*M)(A1, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback1B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback1<void, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	((*_o).*_m)(a1, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 1 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback1B5
    : public XorpConstMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback1B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback1B5() {}
    R dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>::dispatch(a1);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 1 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback1B5<void,O, A1, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback1B5<void, O, A1, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback1B5<void, O, A1, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback1B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback1B5<void, O, A1, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback1B5() {}
    void dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback1B5<void, O, A1, BA1, BA2, BA3, BA4, BA5>::dispatch(a1);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory1B5
{
    static XorpConstMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback1B5<R, O, A1, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 1 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory1B5<R,  const O, A1, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 1 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory1B5<R,  const O, A1, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 1 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback1B6 : public XorpCallback1<R, A1> {
    typedef R (*F)(A1, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback1B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback1<R, A1>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = (*_f)(a1, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 1 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback1B6<void, A1, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback1<void, A1> {
    typedef void (*F)(A1, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback1B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback1<void, A1>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	(*_f)(a1, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 1 dispatch time arguments and 6 bound arguments.
 */
template <class R, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback1<R, A1>::RefPtr(new XorpFunctionCallback1B6<R, A1, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 1 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback1B6 : public XorpCallback1<R, A1> {
    typedef R (O::*M)(A1, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback1B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback1<R, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 1 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback1B6<void, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback1<void, A1> {
    typedef void (O::*M)(A1, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback1B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback1<void, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	((*_o).*_m)(a1, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 1 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback1B6
    : public XorpMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback1B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback1B6() {}
    R dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 1 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback1B6<void,O, A1, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback1B6<void, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback1B6<void, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback1B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback1B6<void, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback1B6() {}
    void dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback1B6<void, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory1B6
{
    static XorpMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 1 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory1B6<R,  O, A1, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 1 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory1B6<R,  O, A1, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 1 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback1B6 : public XorpCallback1<R, A1> {
    typedef R (O::*M)(A1, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback1B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback1<R, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 1 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback1B6<void, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback1<void, A1> {
    typedef void (O::*M)(A1, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback1B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback1<void, A1>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1) {
	record_dispatch_enter();
	((*_o).*_m)(a1, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 1 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback1B6
    : public XorpConstMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback1B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback1B6() {}
    R dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 1 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback1B6<void,O, A1, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback1B6<void, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback1B6<void, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback1B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback1B6<void, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback1B6() {}
    void dispatch(A1 a1) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback1B6<void, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory1B6
{
    static XorpConstMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback1B6<R, O, A1, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 1 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory1B6<R,  const O, A1, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 1 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback1<R, A1>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory1B6<R,  const O, A1, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 2 late args
//

/**
 * @short Base class for callbacks with 2 dispatch time args.
 */
template<class R, class A1, class A2>
struct XorpCallback2 {
    typedef ref_ptr<XorpCallback2> RefPtr;

    XorpCallback2(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback2() {}
    virtual R dispatch(A1, A2) = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 2 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class A1, class A2>
struct XorpFunctionCallback2B0 : public XorpCallback2<R, A1, A2> {
    typedef R (*F)(A1, A2);
    XorpFunctionCallback2B0(const char* file, int line, F f)
	: XorpCallback2<R, A1, A2>(file, line),
	  _f(f)
    {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 2 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class A1, class A2>
struct XorpFunctionCallback2B0<void, A1, A2> : public XorpCallback2<void, A1, A2> {
    typedef void (*F)(A1, A2);
    XorpFunctionCallback2B0(const char* file, int line, F f)
	: XorpCallback2<void, A1, A2>(file, line),
	  _f(f)
    {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	(*_f)(a1, a2);
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 2 dispatch time arguments and 0 bound arguments.
 */
template <class R, class A1, class A2>
typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2)) {
    return typename XorpCallback2<R, A1, A2>::RefPtr(new XorpFunctionCallback2B0<R, A1, A2>(file, line, f));
}

/**
 * @short Callback object for member methods with 2 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2>
struct XorpMemberCallback2B0 : public XorpCallback2<R, A1, A2> {
    typedef R (O::*M)(A1, A2) ;
    XorpMemberCallback2B0(const char* file, int line, O* o, M m)
	 : XorpCallback2<R, A1, A2>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 2 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2>
struct XorpMemberCallback2B0<void, O, A1, A2>
: public XorpCallback2<void, A1, A2> {
    typedef void (O::*M)(A1, A2) ;
    XorpMemberCallback2B0(const char* file, int line, O* o, M m)
	 : XorpCallback2<void, A1, A2>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 2 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2>
struct XorpSafeMemberCallback2B0
    : public XorpMemberCallback2B0<R, O, A1, A2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback2B0<R, O, A1, A2>::M M;
    XorpSafeMemberCallback2B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback2B0<R, O, A1, A2>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback2B0() {}
    R dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback2B0<R, O, A1, A2>::dispatch(a1, a2);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 2 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2>
struct XorpSafeMemberCallback2B0<void,O, A1, A2>
    : public XorpMemberCallback2B0<void, O, A1, A2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback2B0<void, O, A1, A2>::M M;
    XorpSafeMemberCallback2B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback2B0<void, O, A1, A2>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback2B0() {}
    void dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback2B0<void, O, A1, A2>::dispatch(a1, a2);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, bool B=true>
struct XorpMemberCallbackFactory2B0
{
    static XorpMemberCallback2B0<R, O, A1, A2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2))
    {
	return new XorpSafeMemberCallback2B0<R, O, A1, A2>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2>
struct XorpMemberCallbackFactory2B0<R, O, A1, A2, false>
{
    static XorpMemberCallback2B0<R, O, A1, A2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2))
    {
	return new XorpMemberCallback2B0<R, O, A1, A2>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 2 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2))
{
    return XorpMemberCallbackFactory2B0<R,  O, A1, A2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 2 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2))
{
    return XorpMemberCallbackFactory2B0<R,  O, A1, A2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 2 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2>
struct XorpConstMemberCallback2B0 : public XorpCallback2<R, A1, A2> {
    typedef R (O::*M)(A1, A2)  const;
    XorpConstMemberCallback2B0(const char* file, int line, O* o, M m)
	 : XorpCallback2<R, A1, A2>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 2 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2>
struct XorpConstMemberCallback2B0<void, O, A1, A2>
: public XorpCallback2<void, A1, A2> {
    typedef void (O::*M)(A1, A2)  const;
    XorpConstMemberCallback2B0(const char* file, int line, O* o, M m)
	 : XorpCallback2<void, A1, A2>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 2 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2>
struct XorpConstSafeMemberCallback2B0
    : public XorpConstMemberCallback2B0<R, O, A1, A2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback2B0<R, O, A1, A2>::M M;
    XorpConstSafeMemberCallback2B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback2B0<R, O, A1, A2>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback2B0() {}
    R dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback2B0<R, O, A1, A2>::dispatch(a1, a2);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 2 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2>
struct XorpConstSafeMemberCallback2B0<void,O, A1, A2>
    : public XorpConstMemberCallback2B0<void, O, A1, A2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback2B0<void, O, A1, A2>::M M;
    XorpConstSafeMemberCallback2B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback2B0<void, O, A1, A2>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback2B0() {}
    void dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback2B0<void, O, A1, A2>::dispatch(a1, a2);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, bool B=true>
struct XorpConstMemberCallbackFactory2B0
{
    static XorpConstMemberCallback2B0<R, O, A1, A2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2) const)
    {
	return new XorpConstSafeMemberCallback2B0<R, O, A1, A2>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2>
struct XorpConstMemberCallbackFactory2B0<R, O, A1, A2, false>
{
    static XorpConstMemberCallback2B0<R, O, A1, A2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2) const)
    {
	return new XorpConstMemberCallback2B0<R, O, A1, A2>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 2 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2) const)
{
    return XorpConstMemberCallbackFactory2B0<R,  const O, A1, A2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 2 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2) const)
{
    return XorpConstMemberCallbackFactory2B0<R,  const O, A1, A2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 2 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class A1, class A2, class BA1>
struct XorpFunctionCallback2B1 : public XorpCallback2<R, A1, A2> {
    typedef R (*F)(A1, A2, BA1);
    XorpFunctionCallback2B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback2<R, A1, A2>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 2 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class A1, class A2, class BA1>
struct XorpFunctionCallback2B1<void, A1, A2, BA1> : public XorpCallback2<void, A1, A2> {
    typedef void (*F)(A1, A2, BA1);
    XorpFunctionCallback2B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback2<void, A1, A2>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	(*_f)(a1, a2, _ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 2 dispatch time arguments and 1 bound arguments.
 */
template <class R, class A1, class A2, class BA1>
typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, BA1), BA1 ba1) {
    return typename XorpCallback2<R, A1, A2>::RefPtr(new XorpFunctionCallback2B1<R, A1, A2, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 2 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1>
struct XorpMemberCallback2B1 : public XorpCallback2<R, A1, A2> {
    typedef R (O::*M)(A1, A2, BA1) ;
    XorpMemberCallback2B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback2<R, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 2 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1>
struct XorpMemberCallback2B1<void, O, A1, A2, BA1>
: public XorpCallback2<void, A1, A2> {
    typedef void (O::*M)(A1, A2, BA1) ;
    XorpMemberCallback2B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback2<void, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 2 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1>
struct XorpSafeMemberCallback2B1
    : public XorpMemberCallback2B1<R, O, A1, A2, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback2B1<R, O, A1, A2, BA1>::M M;
    XorpSafeMemberCallback2B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback2B1<R, O, A1, A2, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback2B1() {}
    R dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback2B1<R, O, A1, A2, BA1>::dispatch(a1, a2);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 2 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1>
struct XorpSafeMemberCallback2B1<void,O, A1, A2, BA1>
    : public XorpMemberCallback2B1<void, O, A1, A2, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback2B1<void, O, A1, A2, BA1>::M M;
    XorpSafeMemberCallback2B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback2B1<void, O, A1, A2, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback2B1() {}
    void dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback2B1<void, O, A1, A2, BA1>::dispatch(a1, a2);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class BA1, bool B=true>
struct XorpMemberCallbackFactory2B1
{
    static XorpMemberCallback2B1<R, O, A1, A2, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback2B1<R, O, A1, A2, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class BA1>
struct XorpMemberCallbackFactory2B1<R, O, A1, A2, BA1, false>
{
    static XorpMemberCallback2B1<R, O, A1, A2, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1), BA1 ba1)
    {
	return new XorpMemberCallback2B1<R, O, A1, A2, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 2 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory2B1<R,  O, A1, A2, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 2 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory2B1<R,  O, A1, A2, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 2 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1>
struct XorpConstMemberCallback2B1 : public XorpCallback2<R, A1, A2> {
    typedef R (O::*M)(A1, A2, BA1)  const;
    XorpConstMemberCallback2B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback2<R, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 2 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1>
struct XorpConstMemberCallback2B1<void, O, A1, A2, BA1>
: public XorpCallback2<void, A1, A2> {
    typedef void (O::*M)(A1, A2, BA1)  const;
    XorpConstMemberCallback2B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback2<void, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 2 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1>
struct XorpConstSafeMemberCallback2B1
    : public XorpConstMemberCallback2B1<R, O, A1, A2, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback2B1<R, O, A1, A2, BA1>::M M;
    XorpConstSafeMemberCallback2B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback2B1<R, O, A1, A2, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback2B1() {}
    R dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback2B1<R, O, A1, A2, BA1>::dispatch(a1, a2);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 2 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1>
struct XorpConstSafeMemberCallback2B1<void,O, A1, A2, BA1>
    : public XorpConstMemberCallback2B1<void, O, A1, A2, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback2B1<void, O, A1, A2, BA1>::M M;
    XorpConstSafeMemberCallback2B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback2B1<void, O, A1, A2, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback2B1() {}
    void dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback2B1<void, O, A1, A2, BA1>::dispatch(a1, a2);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory2B1
{
    static XorpConstMemberCallback2B1<R, O, A1, A2, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback2B1<R, O, A1, A2, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class BA1>
struct XorpConstMemberCallbackFactory2B1<R, O, A1, A2, BA1, false>
{
    static XorpConstMemberCallback2B1<R, O, A1, A2, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback2B1<R, O, A1, A2, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 2 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory2B1<R,  const O, A1, A2, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 2 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory2B1<R,  const O, A1, A2, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 2 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class A1, class A2, class BA1, class BA2>
struct XorpFunctionCallback2B2 : public XorpCallback2<R, A1, A2> {
    typedef R (*F)(A1, A2, BA1, BA2);
    XorpFunctionCallback2B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback2<R, A1, A2>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 2 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class A1, class A2, class BA1, class BA2>
struct XorpFunctionCallback2B2<void, A1, A2, BA1, BA2> : public XorpCallback2<void, A1, A2> {
    typedef void (*F)(A1, A2, BA1, BA2);
    XorpFunctionCallback2B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback2<void, A1, A2>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	(*_f)(a1, a2, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 2 dispatch time arguments and 2 bound arguments.
 */
template <class R, class A1, class A2, class BA1, class BA2>
typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback2<R, A1, A2>::RefPtr(new XorpFunctionCallback2B2<R, A1, A2, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 2 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2>
struct XorpMemberCallback2B2 : public XorpCallback2<R, A1, A2> {
    typedef R (O::*M)(A1, A2, BA1, BA2) ;
    XorpMemberCallback2B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback2<R, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 2 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2>
struct XorpMemberCallback2B2<void, O, A1, A2, BA1, BA2>
: public XorpCallback2<void, A1, A2> {
    typedef void (O::*M)(A1, A2, BA1, BA2) ;
    XorpMemberCallback2B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback2<void, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 2 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2>
struct XorpSafeMemberCallback2B2
    : public XorpMemberCallback2B2<R, O, A1, A2, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback2B2<R, O, A1, A2, BA1, BA2>::M M;
    XorpSafeMemberCallback2B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback2B2<R, O, A1, A2, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback2B2() {}
    R dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback2B2<R, O, A1, A2, BA1, BA2>::dispatch(a1, a2);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 2 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2>
struct XorpSafeMemberCallback2B2<void,O, A1, A2, BA1, BA2>
    : public XorpMemberCallback2B2<void, O, A1, A2, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback2B2<void, O, A1, A2, BA1, BA2>::M M;
    XorpSafeMemberCallback2B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback2B2<void, O, A1, A2, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback2B2() {}
    void dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback2B2<void, O, A1, A2, BA1, BA2>::dispatch(a1, a2);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory2B2
{
    static XorpMemberCallback2B2<R, O, A1, A2, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback2B2<R, O, A1, A2, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2>
struct XorpMemberCallbackFactory2B2<R, O, A1, A2, BA1, BA2, false>
{
    static XorpMemberCallback2B2<R, O, A1, A2, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback2B2<R, O, A1, A2, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 2 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory2B2<R,  O, A1, A2, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 2 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory2B2<R,  O, A1, A2, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 2 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2>
struct XorpConstMemberCallback2B2 : public XorpCallback2<R, A1, A2> {
    typedef R (O::*M)(A1, A2, BA1, BA2)  const;
    XorpConstMemberCallback2B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback2<R, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 2 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2>
struct XorpConstMemberCallback2B2<void, O, A1, A2, BA1, BA2>
: public XorpCallback2<void, A1, A2> {
    typedef void (O::*M)(A1, A2, BA1, BA2)  const;
    XorpConstMemberCallback2B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback2<void, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 2 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2>
struct XorpConstSafeMemberCallback2B2
    : public XorpConstMemberCallback2B2<R, O, A1, A2, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback2B2<R, O, A1, A2, BA1, BA2>::M M;
    XorpConstSafeMemberCallback2B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback2B2<R, O, A1, A2, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback2B2() {}
    R dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback2B2<R, O, A1, A2, BA1, BA2>::dispatch(a1, a2);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 2 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2>
struct XorpConstSafeMemberCallback2B2<void,O, A1, A2, BA1, BA2>
    : public XorpConstMemberCallback2B2<void, O, A1, A2, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback2B2<void, O, A1, A2, BA1, BA2>::M M;
    XorpConstSafeMemberCallback2B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback2B2<void, O, A1, A2, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback2B2() {}
    void dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback2B2<void, O, A1, A2, BA1, BA2>::dispatch(a1, a2);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory2B2
{
    static XorpConstMemberCallback2B2<R, O, A1, A2, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback2B2<R, O, A1, A2, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2>
struct XorpConstMemberCallbackFactory2B2<R, O, A1, A2, BA1, BA2, false>
{
    static XorpConstMemberCallback2B2<R, O, A1, A2, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback2B2<R, O, A1, A2, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 2 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory2B2<R,  const O, A1, A2, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 2 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory2B2<R,  const O, A1, A2, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 2 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class A1, class A2, class BA1, class BA2, class BA3>
struct XorpFunctionCallback2B3 : public XorpCallback2<R, A1, A2> {
    typedef R (*F)(A1, A2, BA1, BA2, BA3);
    XorpFunctionCallback2B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback2<R, A1, A2>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 2 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class A1, class A2, class BA1, class BA2, class BA3>
struct XorpFunctionCallback2B3<void, A1, A2, BA1, BA2, BA3> : public XorpCallback2<void, A1, A2> {
    typedef void (*F)(A1, A2, BA1, BA2, BA3);
    XorpFunctionCallback2B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback2<void, A1, A2>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	(*_f)(a1, a2, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 2 dispatch time arguments and 3 bound arguments.
 */
template <class R, class A1, class A2, class BA1, class BA2, class BA3>
typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback2<R, A1, A2>::RefPtr(new XorpFunctionCallback2B3<R, A1, A2, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 2 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3>
struct XorpMemberCallback2B3 : public XorpCallback2<R, A1, A2> {
    typedef R (O::*M)(A1, A2, BA1, BA2, BA3) ;
    XorpMemberCallback2B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback2<R, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 2 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3>
struct XorpMemberCallback2B3<void, O, A1, A2, BA1, BA2, BA3>
: public XorpCallback2<void, A1, A2> {
    typedef void (O::*M)(A1, A2, BA1, BA2, BA3) ;
    XorpMemberCallback2B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback2<void, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 2 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback2B3
    : public XorpMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback2B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback2B3() {}
    R dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>::dispatch(a1, a2);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 2 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback2B3<void,O, A1, A2, BA1, BA2, BA3>
    : public XorpMemberCallback2B3<void, O, A1, A2, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback2B3<void, O, A1, A2, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback2B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback2B3<void, O, A1, A2, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback2B3() {}
    void dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback2B3<void, O, A1, A2, BA1, BA2, BA3>::dispatch(a1, a2);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory2B3
{
    static XorpMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory2B3<R, O, A1, A2, BA1, BA2, BA3, false>
{
    static XorpMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 2 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory2B3<R,  O, A1, A2, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 2 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory2B3<R,  O, A1, A2, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 2 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback2B3 : public XorpCallback2<R, A1, A2> {
    typedef R (O::*M)(A1, A2, BA1, BA2, BA3)  const;
    XorpConstMemberCallback2B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback2<R, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 2 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback2B3<void, O, A1, A2, BA1, BA2, BA3>
: public XorpCallback2<void, A1, A2> {
    typedef void (O::*M)(A1, A2, BA1, BA2, BA3)  const;
    XorpConstMemberCallback2B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback2<void, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 2 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback2B3
    : public XorpConstMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback2B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback2B3() {}
    R dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>::dispatch(a1, a2);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 2 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback2B3<void,O, A1, A2, BA1, BA2, BA3>
    : public XorpConstMemberCallback2B3<void, O, A1, A2, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback2B3<void, O, A1, A2, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback2B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback2B3<void, O, A1, A2, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback2B3() {}
    void dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback2B3<void, O, A1, A2, BA1, BA2, BA3>::dispatch(a1, a2);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory2B3
{
    static XorpConstMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory2B3<R, O, A1, A2, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback2B3<R, O, A1, A2, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 2 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory2B3<R,  const O, A1, A2, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 2 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory2B3<R,  const O, A1, A2, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 2 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class A1, class A2, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback2B4 : public XorpCallback2<R, A1, A2> {
    typedef R (*F)(A1, A2, BA1, BA2, BA3, BA4);
    XorpFunctionCallback2B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback2<R, A1, A2>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 2 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class A1, class A2, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback2B4<void, A1, A2, BA1, BA2, BA3, BA4> : public XorpCallback2<void, A1, A2> {
    typedef void (*F)(A1, A2, BA1, BA2, BA3, BA4);
    XorpFunctionCallback2B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback2<void, A1, A2>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	(*_f)(a1, a2, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 2 dispatch time arguments and 4 bound arguments.
 */
template <class R, class A1, class A2, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback2<R, A1, A2>::RefPtr(new XorpFunctionCallback2B4<R, A1, A2, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 2 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback2B4 : public XorpCallback2<R, A1, A2> {
    typedef R (O::*M)(A1, A2, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback2B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback2<R, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 2 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback2B4<void, O, A1, A2, BA1, BA2, BA3, BA4>
: public XorpCallback2<void, A1, A2> {
    typedef void (O::*M)(A1, A2, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback2B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback2<void, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 2 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback2B4
    : public XorpMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback2B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback2B4() {}
    R dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>::dispatch(a1, a2);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 2 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback2B4<void,O, A1, A2, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback2B4<void, O, A1, A2, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback2B4<void, O, A1, A2, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback2B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback2B4<void, O, A1, A2, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback2B4() {}
    void dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback2B4<void, O, A1, A2, BA1, BA2, BA3, BA4>::dispatch(a1, a2);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory2B4
{
    static XorpMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory2B4<R, O, A1, A2, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 2 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory2B4<R,  O, A1, A2, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 2 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory2B4<R,  O, A1, A2, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 2 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback2B4 : public XorpCallback2<R, A1, A2> {
    typedef R (O::*M)(A1, A2, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback2B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback2<R, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 2 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback2B4<void, O, A1, A2, BA1, BA2, BA3, BA4>
: public XorpCallback2<void, A1, A2> {
    typedef void (O::*M)(A1, A2, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback2B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback2<void, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 2 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback2B4
    : public XorpConstMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback2B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback2B4() {}
    R dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>::dispatch(a1, a2);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 2 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback2B4<void,O, A1, A2, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback2B4<void, O, A1, A2, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback2B4<void, O, A1, A2, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback2B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback2B4<void, O, A1, A2, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback2B4() {}
    void dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback2B4<void, O, A1, A2, BA1, BA2, BA3, BA4>::dispatch(a1, a2);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory2B4
{
    static XorpConstMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory2B4<R, O, A1, A2, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback2B4<R, O, A1, A2, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 2 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory2B4<R,  const O, A1, A2, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 2 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory2B4<R,  const O, A1, A2, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 2 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback2B5 : public XorpCallback2<R, A1, A2> {
    typedef R (*F)(A1, A2, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback2B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback2<R, A1, A2>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 2 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback2B5<void, A1, A2, BA1, BA2, BA3, BA4, BA5> : public XorpCallback2<void, A1, A2> {
    typedef void (*F)(A1, A2, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback2B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback2<void, A1, A2>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	(*_f)(a1, a2, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 2 dispatch time arguments and 5 bound arguments.
 */
template <class R, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback2<R, A1, A2>::RefPtr(new XorpFunctionCallback2B5<R, A1, A2, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 2 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback2B5 : public XorpCallback2<R, A1, A2> {
    typedef R (O::*M)(A1, A2, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback2B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback2<R, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 2 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback2B5<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback2<void, A1, A2> {
    typedef void (O::*M)(A1, A2, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback2B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback2<void, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 2 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback2B5
    : public XorpMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback2B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback2B5() {}
    R dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 2 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback2B5<void,O, A1, A2, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback2B5<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback2B5<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback2B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback2B5<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback2B5() {}
    void dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback2B5<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory2B5
{
    static XorpMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 2 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory2B5<R,  O, A1, A2, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 2 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory2B5<R,  O, A1, A2, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 2 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback2B5 : public XorpCallback2<R, A1, A2> {
    typedef R (O::*M)(A1, A2, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback2B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback2<R, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 2 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback2B5<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback2<void, A1, A2> {
    typedef void (O::*M)(A1, A2, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback2B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback2<void, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 2 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback2B5
    : public XorpConstMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback2B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback2B5() {}
    R dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 2 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback2B5<void,O, A1, A2, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback2B5<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback2B5<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback2B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback2B5<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback2B5() {}
    void dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback2B5<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory2B5
{
    static XorpConstMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback2B5<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 2 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory2B5<R,  const O, A1, A2, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 2 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory2B5<R,  const O, A1, A2, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 2 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback2B6 : public XorpCallback2<R, A1, A2> {
    typedef R (*F)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback2B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback2<R, A1, A2>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 2 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback2B6<void, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback2<void, A1, A2> {
    typedef void (*F)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback2B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback2<void, A1, A2>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	(*_f)(a1, a2, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 2 dispatch time arguments and 6 bound arguments.
 */
template <class R, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback2<R, A1, A2>::RefPtr(new XorpFunctionCallback2B6<R, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 2 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback2B6 : public XorpCallback2<R, A1, A2> {
    typedef R (O::*M)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback2B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback2<R, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 2 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback2B6<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback2<void, A1, A2> {
    typedef void (O::*M)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback2B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback2<void, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 2 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback2B6
    : public XorpMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback2B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback2B6() {}
    R dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 2 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback2B6<void,O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback2B6<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback2B6<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback2B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback2B6<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback2B6() {}
    void dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback2B6<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory2B6
{
    static XorpMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 2 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory2B6<R,  O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 2 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory2B6<R,  O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 2 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback2B6 : public XorpCallback2<R, A1, A2> {
    typedef R (O::*M)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback2B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback2<R, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 2 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback2B6<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback2<void, A1, A2> {
    typedef void (O::*M)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback2B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback2<void, A1, A2>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 2 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback2B6
    : public XorpConstMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback2B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback2B6() {}
    R dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 2 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback2B6<void,O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback2B6<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback2B6<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback2B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback2B6<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback2B6() {}
    void dispatch(A1 a1, A2 a2) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback2B6<void, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory2B6
{
    static XorpConstMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback2B6<R, O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 2 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory2B6<R,  const O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 2 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback2<R, A1, A2>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory2B6<R,  const O, A1, A2, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 3 late args
//

/**
 * @short Base class for callbacks with 3 dispatch time args.
 */
template<class R, class A1, class A2, class A3>
struct XorpCallback3 {
    typedef ref_ptr<XorpCallback3> RefPtr;

    XorpCallback3(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback3() {}
    virtual R dispatch(A1, A2, A3) = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 3 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3>
struct XorpFunctionCallback3B0 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (*F)(A1, A2, A3);
    XorpFunctionCallback3B0(const char* file, int line, F f)
	: XorpCallback3<R, A1, A2, A3>(file, line),
	  _f(f)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 3 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class A1, class A2, class A3>
struct XorpFunctionCallback3B0<void, A1, A2, A3> : public XorpCallback3<void, A1, A2, A3> {
    typedef void (*F)(A1, A2, A3);
    XorpFunctionCallback3B0(const char* file, int line, F f)
	: XorpCallback3<void, A1, A2, A3>(file, line),
	  _f(f)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3);
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 3 dispatch time arguments and 0 bound arguments.
 */
template <class R, class A1, class A2, class A3>
typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3)) {
    return typename XorpCallback3<R, A1, A2, A3>::RefPtr(new XorpFunctionCallback3B0<R, A1, A2, A3>(file, line, f));
}

/**
 * @short Callback object for member methods with 3 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3>
struct XorpMemberCallback3B0 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (O::*M)(A1, A2, A3) ;
    XorpMemberCallback3B0(const char* file, int line, O* o, M m)
	 : XorpCallback3<R, A1, A2, A3>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 3 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3>
struct XorpMemberCallback3B0<void, O, A1, A2, A3>
: public XorpCallback3<void, A1, A2, A3> {
    typedef void (O::*M)(A1, A2, A3) ;
    XorpMemberCallback3B0(const char* file, int line, O* o, M m)
	 : XorpCallback3<void, A1, A2, A3>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 3 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3>
struct XorpSafeMemberCallback3B0
    : public XorpMemberCallback3B0<R, O, A1, A2, A3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback3B0<R, O, A1, A2, A3>::M M;
    XorpSafeMemberCallback3B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback3B0<R, O, A1, A2, A3>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback3B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback3B0<R, O, A1, A2, A3>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 3 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3>
struct XorpSafeMemberCallback3B0<void,O, A1, A2, A3>
    : public XorpMemberCallback3B0<void, O, A1, A2, A3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback3B0<void, O, A1, A2, A3>::M M;
    XorpSafeMemberCallback3B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback3B0<void, O, A1, A2, A3>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback3B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback3B0<void, O, A1, A2, A3>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, bool B=true>
struct XorpMemberCallbackFactory3B0
{
    static XorpMemberCallback3B0<R, O, A1, A2, A3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3))
    {
	return new XorpSafeMemberCallback3B0<R, O, A1, A2, A3>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3>
struct XorpMemberCallbackFactory3B0<R, O, A1, A2, A3, false>
{
    static XorpMemberCallback3B0<R, O, A1, A2, A3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3))
    {
	return new XorpMemberCallback3B0<R, O, A1, A2, A3>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 3 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3))
{
    return XorpMemberCallbackFactory3B0<R,  O, A1, A2, A3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 3 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3))
{
    return XorpMemberCallbackFactory3B0<R,  O, A1, A2, A3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 3 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3>
struct XorpConstMemberCallback3B0 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (O::*M)(A1, A2, A3)  const;
    XorpConstMemberCallback3B0(const char* file, int line, O* o, M m)
	 : XorpCallback3<R, A1, A2, A3>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 3 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3>
struct XorpConstMemberCallback3B0<void, O, A1, A2, A3>
: public XorpCallback3<void, A1, A2, A3> {
    typedef void (O::*M)(A1, A2, A3)  const;
    XorpConstMemberCallback3B0(const char* file, int line, O* o, M m)
	 : XorpCallback3<void, A1, A2, A3>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 3 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3>
struct XorpConstSafeMemberCallback3B0
    : public XorpConstMemberCallback3B0<R, O, A1, A2, A3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback3B0<R, O, A1, A2, A3>::M M;
    XorpConstSafeMemberCallback3B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback3B0<R, O, A1, A2, A3>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback3B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback3B0<R, O, A1, A2, A3>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 3 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3>
struct XorpConstSafeMemberCallback3B0<void,O, A1, A2, A3>
    : public XorpConstMemberCallback3B0<void, O, A1, A2, A3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback3B0<void, O, A1, A2, A3>::M M;
    XorpConstSafeMemberCallback3B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback3B0<void, O, A1, A2, A3>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback3B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback3B0<void, O, A1, A2, A3>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, bool B=true>
struct XorpConstMemberCallbackFactory3B0
{
    static XorpConstMemberCallback3B0<R, O, A1, A2, A3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3) const)
    {
	return new XorpConstSafeMemberCallback3B0<R, O, A1, A2, A3>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3>
struct XorpConstMemberCallbackFactory3B0<R, O, A1, A2, A3, false>
{
    static XorpConstMemberCallback3B0<R, O, A1, A2, A3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3) const)
    {
	return new XorpConstMemberCallback3B0<R, O, A1, A2, A3>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 3 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3) const)
{
    return XorpConstMemberCallbackFactory3B0<R,  const O, A1, A2, A3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 3 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3) const)
{
    return XorpConstMemberCallbackFactory3B0<R,  const O, A1, A2, A3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 3 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class BA1>
struct XorpFunctionCallback3B1 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (*F)(A1, A2, A3, BA1);
    XorpFunctionCallback3B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback3<R, A1, A2, A3>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 3 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class BA1>
struct XorpFunctionCallback3B1<void, A1, A2, A3, BA1> : public XorpCallback3<void, A1, A2, A3> {
    typedef void (*F)(A1, A2, A3, BA1);
    XorpFunctionCallback3B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback3<void, A1, A2, A3>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, _ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 3 dispatch time arguments and 1 bound arguments.
 */
template <class R, class A1, class A2, class A3, class BA1>
typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, BA1), BA1 ba1) {
    return typename XorpCallback3<R, A1, A2, A3>::RefPtr(new XorpFunctionCallback3B1<R, A1, A2, A3, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 3 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1>
struct XorpMemberCallback3B1 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (O::*M)(A1, A2, A3, BA1) ;
    XorpMemberCallback3B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback3<R, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 3 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1>
struct XorpMemberCallback3B1<void, O, A1, A2, A3, BA1>
: public XorpCallback3<void, A1, A2, A3> {
    typedef void (O::*M)(A1, A2, A3, BA1) ;
    XorpMemberCallback3B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback3<void, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 3 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1>
struct XorpSafeMemberCallback3B1
    : public XorpMemberCallback3B1<R, O, A1, A2, A3, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback3B1<R, O, A1, A2, A3, BA1>::M M;
    XorpSafeMemberCallback3B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback3B1<R, O, A1, A2, A3, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback3B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback3B1<R, O, A1, A2, A3, BA1>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 3 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1>
struct XorpSafeMemberCallback3B1<void,O, A1, A2, A3, BA1>
    : public XorpMemberCallback3B1<void, O, A1, A2, A3, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback3B1<void, O, A1, A2, A3, BA1>::M M;
    XorpSafeMemberCallback3B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback3B1<void, O, A1, A2, A3, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback3B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback3B1<void, O, A1, A2, A3, BA1>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, bool B=true>
struct XorpMemberCallbackFactory3B1
{
    static XorpMemberCallback3B1<R, O, A1, A2, A3, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback3B1<R, O, A1, A2, A3, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1>
struct XorpMemberCallbackFactory3B1<R, O, A1, A2, A3, BA1, false>
{
    static XorpMemberCallback3B1<R, O, A1, A2, A3, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1), BA1 ba1)
    {
	return new XorpMemberCallback3B1<R, O, A1, A2, A3, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 3 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory3B1<R,  O, A1, A2, A3, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 3 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory3B1<R,  O, A1, A2, A3, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 3 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1>
struct XorpConstMemberCallback3B1 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (O::*M)(A1, A2, A3, BA1)  const;
    XorpConstMemberCallback3B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback3<R, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 3 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1>
struct XorpConstMemberCallback3B1<void, O, A1, A2, A3, BA1>
: public XorpCallback3<void, A1, A2, A3> {
    typedef void (O::*M)(A1, A2, A3, BA1)  const;
    XorpConstMemberCallback3B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback3<void, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 3 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1>
struct XorpConstSafeMemberCallback3B1
    : public XorpConstMemberCallback3B1<R, O, A1, A2, A3, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback3B1<R, O, A1, A2, A3, BA1>::M M;
    XorpConstSafeMemberCallback3B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback3B1<R, O, A1, A2, A3, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback3B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback3B1<R, O, A1, A2, A3, BA1>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 3 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1>
struct XorpConstSafeMemberCallback3B1<void,O, A1, A2, A3, BA1>
    : public XorpConstMemberCallback3B1<void, O, A1, A2, A3, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback3B1<void, O, A1, A2, A3, BA1>::M M;
    XorpConstSafeMemberCallback3B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback3B1<void, O, A1, A2, A3, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback3B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback3B1<void, O, A1, A2, A3, BA1>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory3B1
{
    static XorpConstMemberCallback3B1<R, O, A1, A2, A3, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback3B1<R, O, A1, A2, A3, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1>
struct XorpConstMemberCallbackFactory3B1<R, O, A1, A2, A3, BA1, false>
{
    static XorpConstMemberCallback3B1<R, O, A1, A2, A3, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback3B1<R, O, A1, A2, A3, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 3 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory3B1<R,  const O, A1, A2, A3, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 3 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory3B1<R,  const O, A1, A2, A3, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 3 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class BA1, class BA2>
struct XorpFunctionCallback3B2 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (*F)(A1, A2, A3, BA1, BA2);
    XorpFunctionCallback3B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback3<R, A1, A2, A3>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 3 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class BA1, class BA2>
struct XorpFunctionCallback3B2<void, A1, A2, A3, BA1, BA2> : public XorpCallback3<void, A1, A2, A3> {
    typedef void (*F)(A1, A2, A3, BA1, BA2);
    XorpFunctionCallback3B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback3<void, A1, A2, A3>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 3 dispatch time arguments and 2 bound arguments.
 */
template <class R, class A1, class A2, class A3, class BA1, class BA2>
typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback3<R, A1, A2, A3>::RefPtr(new XorpFunctionCallback3B2<R, A1, A2, A3, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 3 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2>
struct XorpMemberCallback3B2 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (O::*M)(A1, A2, A3, BA1, BA2) ;
    XorpMemberCallback3B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback3<R, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 3 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2>
struct XorpMemberCallback3B2<void, O, A1, A2, A3, BA1, BA2>
: public XorpCallback3<void, A1, A2, A3> {
    typedef void (O::*M)(A1, A2, A3, BA1, BA2) ;
    XorpMemberCallback3B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback3<void, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 3 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2>
struct XorpSafeMemberCallback3B2
    : public XorpMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>::M M;
    XorpSafeMemberCallback3B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback3B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 3 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2>
struct XorpSafeMemberCallback3B2<void,O, A1, A2, A3, BA1, BA2>
    : public XorpMemberCallback3B2<void, O, A1, A2, A3, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback3B2<void, O, A1, A2, A3, BA1, BA2>::M M;
    XorpSafeMemberCallback3B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback3B2<void, O, A1, A2, A3, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback3B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback3B2<void, O, A1, A2, A3, BA1, BA2>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory3B2
{
    static XorpMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2>
struct XorpMemberCallbackFactory3B2<R, O, A1, A2, A3, BA1, BA2, false>
{
    static XorpMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 3 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory3B2<R,  O, A1, A2, A3, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 3 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory3B2<R,  O, A1, A2, A3, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 3 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2>
struct XorpConstMemberCallback3B2 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (O::*M)(A1, A2, A3, BA1, BA2)  const;
    XorpConstMemberCallback3B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback3<R, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 3 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2>
struct XorpConstMemberCallback3B2<void, O, A1, A2, A3, BA1, BA2>
: public XorpCallback3<void, A1, A2, A3> {
    typedef void (O::*M)(A1, A2, A3, BA1, BA2)  const;
    XorpConstMemberCallback3B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback3<void, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 3 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2>
struct XorpConstSafeMemberCallback3B2
    : public XorpConstMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>::M M;
    XorpConstSafeMemberCallback3B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback3B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 3 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2>
struct XorpConstSafeMemberCallback3B2<void,O, A1, A2, A3, BA1, BA2>
    : public XorpConstMemberCallback3B2<void, O, A1, A2, A3, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback3B2<void, O, A1, A2, A3, BA1, BA2>::M M;
    XorpConstSafeMemberCallback3B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback3B2<void, O, A1, A2, A3, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback3B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback3B2<void, O, A1, A2, A3, BA1, BA2>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory3B2
{
    static XorpConstMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2>
struct XorpConstMemberCallbackFactory3B2<R, O, A1, A2, A3, BA1, BA2, false>
{
    static XorpConstMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback3B2<R, O, A1, A2, A3, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 3 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory3B2<R,  const O, A1, A2, A3, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 3 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory3B2<R,  const O, A1, A2, A3, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 3 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class BA1, class BA2, class BA3>
struct XorpFunctionCallback3B3 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (*F)(A1, A2, A3, BA1, BA2, BA3);
    XorpFunctionCallback3B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback3<R, A1, A2, A3>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 3 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class BA1, class BA2, class BA3>
struct XorpFunctionCallback3B3<void, A1, A2, A3, BA1, BA2, BA3> : public XorpCallback3<void, A1, A2, A3> {
    typedef void (*F)(A1, A2, A3, BA1, BA2, BA3);
    XorpFunctionCallback3B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback3<void, A1, A2, A3>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 3 dispatch time arguments and 3 bound arguments.
 */
template <class R, class A1, class A2, class A3, class BA1, class BA2, class BA3>
typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback3<R, A1, A2, A3>::RefPtr(new XorpFunctionCallback3B3<R, A1, A2, A3, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 3 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3>
struct XorpMemberCallback3B3 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (O::*M)(A1, A2, A3, BA1, BA2, BA3) ;
    XorpMemberCallback3B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback3<R, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 3 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3>
struct XorpMemberCallback3B3<void, O, A1, A2, A3, BA1, BA2, BA3>
: public XorpCallback3<void, A1, A2, A3> {
    typedef void (O::*M)(A1, A2, A3, BA1, BA2, BA3) ;
    XorpMemberCallback3B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback3<void, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 3 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback3B3
    : public XorpMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback3B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback3B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 3 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback3B3<void,O, A1, A2, A3, BA1, BA2, BA3>
    : public XorpMemberCallback3B3<void, O, A1, A2, A3, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback3B3<void, O, A1, A2, A3, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback3B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback3B3<void, O, A1, A2, A3, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback3B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback3B3<void, O, A1, A2, A3, BA1, BA2, BA3>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory3B3
{
    static XorpMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory3B3<R, O, A1, A2, A3, BA1, BA2, BA3, false>
{
    static XorpMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 3 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory3B3<R,  O, A1, A2, A3, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 3 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory3B3<R,  O, A1, A2, A3, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 3 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback3B3 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (O::*M)(A1, A2, A3, BA1, BA2, BA3)  const;
    XorpConstMemberCallback3B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback3<R, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 3 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback3B3<void, O, A1, A2, A3, BA1, BA2, BA3>
: public XorpCallback3<void, A1, A2, A3> {
    typedef void (O::*M)(A1, A2, A3, BA1, BA2, BA3)  const;
    XorpConstMemberCallback3B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback3<void, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 3 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback3B3
    : public XorpConstMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback3B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback3B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 3 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback3B3<void,O, A1, A2, A3, BA1, BA2, BA3>
    : public XorpConstMemberCallback3B3<void, O, A1, A2, A3, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback3B3<void, O, A1, A2, A3, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback3B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback3B3<void, O, A1, A2, A3, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback3B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback3B3<void, O, A1, A2, A3, BA1, BA2, BA3>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory3B3
{
    static XorpConstMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory3B3<R, O, A1, A2, A3, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback3B3<R, O, A1, A2, A3, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 3 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory3B3<R,  const O, A1, A2, A3, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 3 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory3B3<R,  const O, A1, A2, A3, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 3 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback3B4 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (*F)(A1, A2, A3, BA1, BA2, BA3, BA4);
    XorpFunctionCallback3B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback3<R, A1, A2, A3>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 3 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback3B4<void, A1, A2, A3, BA1, BA2, BA3, BA4> : public XorpCallback3<void, A1, A2, A3> {
    typedef void (*F)(A1, A2, A3, BA1, BA2, BA3, BA4);
    XorpFunctionCallback3B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback3<void, A1, A2, A3>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 3 dispatch time arguments and 4 bound arguments.
 */
template <class R, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback3<R, A1, A2, A3>::RefPtr(new XorpFunctionCallback3B4<R, A1, A2, A3, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 3 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback3B4 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (O::*M)(A1, A2, A3, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback3B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback3<R, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 3 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback3B4<void, O, A1, A2, A3, BA1, BA2, BA3, BA4>
: public XorpCallback3<void, A1, A2, A3> {
    typedef void (O::*M)(A1, A2, A3, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback3B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback3<void, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 3 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback3B4
    : public XorpMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback3B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback3B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 3 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback3B4<void,O, A1, A2, A3, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback3B4<void, O, A1, A2, A3, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback3B4<void, O, A1, A2, A3, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback3B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback3B4<void, O, A1, A2, A3, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback3B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback3B4<void, O, A1, A2, A3, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory3B4
{
    static XorpMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 3 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory3B4<R,  O, A1, A2, A3, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 3 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory3B4<R,  O, A1, A2, A3, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 3 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback3B4 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (O::*M)(A1, A2, A3, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback3B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback3<R, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 3 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback3B4<void, O, A1, A2, A3, BA1, BA2, BA3, BA4>
: public XorpCallback3<void, A1, A2, A3> {
    typedef void (O::*M)(A1, A2, A3, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback3B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback3<void, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 3 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback3B4
    : public XorpConstMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback3B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback3B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 3 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback3B4<void,O, A1, A2, A3, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback3B4<void, O, A1, A2, A3, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback3B4<void, O, A1, A2, A3, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback3B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback3B4<void, O, A1, A2, A3, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback3B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback3B4<void, O, A1, A2, A3, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory3B4
{
    static XorpConstMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback3B4<R, O, A1, A2, A3, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 3 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory3B4<R,  const O, A1, A2, A3, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 3 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory3B4<R,  const O, A1, A2, A3, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 3 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback3B5 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (*F)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback3B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback3<R, A1, A2, A3>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 3 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback3B5<void, A1, A2, A3, BA1, BA2, BA3, BA4, BA5> : public XorpCallback3<void, A1, A2, A3> {
    typedef void (*F)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback3B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback3<void, A1, A2, A3>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 3 dispatch time arguments and 5 bound arguments.
 */
template <class R, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback3<R, A1, A2, A3>::RefPtr(new XorpFunctionCallback3B5<R, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 3 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback3B5 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (O::*M)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback3B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback3<R, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 3 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback3B5<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback3<void, A1, A2, A3> {
    typedef void (O::*M)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback3B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback3<void, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 3 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback3B5
    : public XorpMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback3B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback3B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 3 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback3B5<void,O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback3B5<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback3B5<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback3B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback3B5<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback3B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback3B5<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory3B5
{
    static XorpMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 3 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory3B5<R,  O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 3 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory3B5<R,  O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 3 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback3B5 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (O::*M)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback3B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback3<R, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 3 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback3B5<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback3<void, A1, A2, A3> {
    typedef void (O::*M)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback3B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback3<void, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 3 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback3B5
    : public XorpConstMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback3B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback3B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 3 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback3B5<void,O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback3B5<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback3B5<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback3B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback3B5<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback3B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback3B5<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory3B5
{
    static XorpConstMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback3B5<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 3 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory3B5<R,  const O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 3 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory3B5<R,  const O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 3 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback3B6 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (*F)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback3B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback3<R, A1, A2, A3>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 3 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback3B6<void, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback3<void, A1, A2, A3> {
    typedef void (*F)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback3B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback3<void, A1, A2, A3>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 3 dispatch time arguments and 6 bound arguments.
 */
template <class R, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback3<R, A1, A2, A3>::RefPtr(new XorpFunctionCallback3B6<R, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 3 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback3B6 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (O::*M)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback3B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback3<R, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 3 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback3B6<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback3<void, A1, A2, A3> {
    typedef void (O::*M)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback3B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback3<void, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 3 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback3B6
    : public XorpMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback3B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback3B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 3 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback3B6<void,O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback3B6<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback3B6<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback3B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback3B6<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback3B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback3B6<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory3B6
{
    static XorpMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 3 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory3B6<R,  O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 3 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory3B6<R,  O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 3 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback3B6 : public XorpCallback3<R, A1, A2, A3> {
    typedef R (O::*M)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback3B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback3<R, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 3 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback3B6<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback3<void, A1, A2, A3> {
    typedef void (O::*M)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback3B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback3<void, A1, A2, A3>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 3 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback3B6
    : public XorpConstMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback3B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback3B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 3 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback3B6<void,O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback3B6<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback3B6<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback3B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback3B6<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback3B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback3B6<void, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory3B6
{
    static XorpConstMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback3B6<R, O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 3 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory3B6<R,  const O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 3 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback3<R, A1, A2, A3>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory3B6<R,  const O, A1, A2, A3, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 4 late args
//

/**
 * @short Base class for callbacks with 4 dispatch time args.
 */
template<class R, class A1, class A2, class A3, class A4>
struct XorpCallback4 {
    typedef ref_ptr<XorpCallback4> RefPtr;

    XorpCallback4(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback4() {}
    virtual R dispatch(A1, A2, A3, A4) = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 4 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4>
struct XorpFunctionCallback4B0 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (*F)(A1, A2, A3, A4);
    XorpFunctionCallback4B0(const char* file, int line, F f)
	: XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _f(f)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 4 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4>
struct XorpFunctionCallback4B0<void, A1, A2, A3, A4> : public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (*F)(A1, A2, A3, A4);
    XorpFunctionCallback4B0(const char* file, int line, F f)
	: XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _f(f)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4);
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 4 dispatch time arguments and 0 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4>
typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4)) {
    return typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr(new XorpFunctionCallback4B0<R, A1, A2, A3, A4>(file, line, f));
}

/**
 * @short Callback object for member methods with 4 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4>
struct XorpMemberCallback4B0 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (O::*M)(A1, A2, A3, A4) ;
    XorpMemberCallback4B0(const char* file, int line, O* o, M m)
	 : XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 4 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4>
struct XorpMemberCallback4B0<void, O, A1, A2, A3, A4>
: public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (O::*M)(A1, A2, A3, A4) ;
    XorpMemberCallback4B0(const char* file, int line, O* o, M m)
	 : XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 4 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4>
struct XorpSafeMemberCallback4B0
    : public XorpMemberCallback4B0<R, O, A1, A2, A3, A4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback4B0<R, O, A1, A2, A3, A4>::M M;
    XorpSafeMemberCallback4B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback4B0<R, O, A1, A2, A3, A4>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback4B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback4B0<R, O, A1, A2, A3, A4>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 4 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4>
struct XorpSafeMemberCallback4B0<void,O, A1, A2, A3, A4>
    : public XorpMemberCallback4B0<void, O, A1, A2, A3, A4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback4B0<void, O, A1, A2, A3, A4>::M M;
    XorpSafeMemberCallback4B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback4B0<void, O, A1, A2, A3, A4>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback4B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback4B0<void, O, A1, A2, A3, A4>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, bool B=true>
struct XorpMemberCallbackFactory4B0
{
    static XorpMemberCallback4B0<R, O, A1, A2, A3, A4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4))
    {
	return new XorpSafeMemberCallback4B0<R, O, A1, A2, A3, A4>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4>
struct XorpMemberCallbackFactory4B0<R, O, A1, A2, A3, A4, false>
{
    static XorpMemberCallback4B0<R, O, A1, A2, A3, A4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4))
    {
	return new XorpMemberCallback4B0<R, O, A1, A2, A3, A4>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 4 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4))
{
    return XorpMemberCallbackFactory4B0<R,  O, A1, A2, A3, A4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 4 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4))
{
    return XorpMemberCallbackFactory4B0<R,  O, A1, A2, A3, A4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 4 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4>
struct XorpConstMemberCallback4B0 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (O::*M)(A1, A2, A3, A4)  const;
    XorpConstMemberCallback4B0(const char* file, int line, O* o, M m)
	 : XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 4 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4>
struct XorpConstMemberCallback4B0<void, O, A1, A2, A3, A4>
: public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (O::*M)(A1, A2, A3, A4)  const;
    XorpConstMemberCallback4B0(const char* file, int line, O* o, M m)
	 : XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 4 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4>
struct XorpConstSafeMemberCallback4B0
    : public XorpConstMemberCallback4B0<R, O, A1, A2, A3, A4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback4B0<R, O, A1, A2, A3, A4>::M M;
    XorpConstSafeMemberCallback4B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback4B0<R, O, A1, A2, A3, A4>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback4B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback4B0<R, O, A1, A2, A3, A4>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 4 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4>
struct XorpConstSafeMemberCallback4B0<void,O, A1, A2, A3, A4>
    : public XorpConstMemberCallback4B0<void, O, A1, A2, A3, A4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback4B0<void, O, A1, A2, A3, A4>::M M;
    XorpConstSafeMemberCallback4B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback4B0<void, O, A1, A2, A3, A4>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback4B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback4B0<void, O, A1, A2, A3, A4>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, bool B=true>
struct XorpConstMemberCallbackFactory4B0
{
    static XorpConstMemberCallback4B0<R, O, A1, A2, A3, A4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4) const)
    {
	return new XorpConstSafeMemberCallback4B0<R, O, A1, A2, A3, A4>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4>
struct XorpConstMemberCallbackFactory4B0<R, O, A1, A2, A3, A4, false>
{
    static XorpConstMemberCallback4B0<R, O, A1, A2, A3, A4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4) const)
    {
	return new XorpConstMemberCallback4B0<R, O, A1, A2, A3, A4>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 4 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4) const)
{
    return XorpConstMemberCallbackFactory4B0<R,  const O, A1, A2, A3, A4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 4 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4) const)
{
    return XorpConstMemberCallbackFactory4B0<R,  const O, A1, A2, A3, A4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 4 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class BA1>
struct XorpFunctionCallback4B1 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (*F)(A1, A2, A3, A4, BA1);
    XorpFunctionCallback4B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 4 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class BA1>
struct XorpFunctionCallback4B1<void, A1, A2, A3, A4, BA1> : public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (*F)(A1, A2, A3, A4, BA1);
    XorpFunctionCallback4B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, _ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 4 dispatch time arguments and 1 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class BA1>
typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, BA1), BA1 ba1) {
    return typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr(new XorpFunctionCallback4B1<R, A1, A2, A3, A4, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 4 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1>
struct XorpMemberCallback4B1 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (O::*M)(A1, A2, A3, A4, BA1) ;
    XorpMemberCallback4B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 4 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1>
struct XorpMemberCallback4B1<void, O, A1, A2, A3, A4, BA1>
: public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (O::*M)(A1, A2, A3, A4, BA1) ;
    XorpMemberCallback4B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 4 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1>
struct XorpSafeMemberCallback4B1
    : public XorpMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>::M M;
    XorpSafeMemberCallback4B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback4B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 4 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1>
struct XorpSafeMemberCallback4B1<void,O, A1, A2, A3, A4, BA1>
    : public XorpMemberCallback4B1<void, O, A1, A2, A3, A4, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback4B1<void, O, A1, A2, A3, A4, BA1>::M M;
    XorpSafeMemberCallback4B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback4B1<void, O, A1, A2, A3, A4, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback4B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback4B1<void, O, A1, A2, A3, A4, BA1>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, bool B=true>
struct XorpMemberCallbackFactory4B1
{
    static XorpMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1>
struct XorpMemberCallbackFactory4B1<R, O, A1, A2, A3, A4, BA1, false>
{
    static XorpMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1), BA1 ba1)
    {
	return new XorpMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 4 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory4B1<R,  O, A1, A2, A3, A4, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 4 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory4B1<R,  O, A1, A2, A3, A4, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 4 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1>
struct XorpConstMemberCallback4B1 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (O::*M)(A1, A2, A3, A4, BA1)  const;
    XorpConstMemberCallback4B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 4 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1>
struct XorpConstMemberCallback4B1<void, O, A1, A2, A3, A4, BA1>
: public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (O::*M)(A1, A2, A3, A4, BA1)  const;
    XorpConstMemberCallback4B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 4 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1>
struct XorpConstSafeMemberCallback4B1
    : public XorpConstMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>::M M;
    XorpConstSafeMemberCallback4B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback4B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 4 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1>
struct XorpConstSafeMemberCallback4B1<void,O, A1, A2, A3, A4, BA1>
    : public XorpConstMemberCallback4B1<void, O, A1, A2, A3, A4, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback4B1<void, O, A1, A2, A3, A4, BA1>::M M;
    XorpConstSafeMemberCallback4B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback4B1<void, O, A1, A2, A3, A4, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback4B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback4B1<void, O, A1, A2, A3, A4, BA1>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory4B1
{
    static XorpConstMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1>
struct XorpConstMemberCallbackFactory4B1<R, O, A1, A2, A3, A4, BA1, false>
{
    static XorpConstMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback4B1<R, O, A1, A2, A3, A4, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 4 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory4B1<R,  const O, A1, A2, A3, A4, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 4 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory4B1<R,  const O, A1, A2, A3, A4, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 4 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class BA1, class BA2>
struct XorpFunctionCallback4B2 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (*F)(A1, A2, A3, A4, BA1, BA2);
    XorpFunctionCallback4B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 4 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class BA1, class BA2>
struct XorpFunctionCallback4B2<void, A1, A2, A3, A4, BA1, BA2> : public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (*F)(A1, A2, A3, A4, BA1, BA2);
    XorpFunctionCallback4B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 4 dispatch time arguments and 2 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class BA1, class BA2>
typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr(new XorpFunctionCallback4B2<R, A1, A2, A3, A4, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 4 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2>
struct XorpMemberCallback4B2 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (O::*M)(A1, A2, A3, A4, BA1, BA2) ;
    XorpMemberCallback4B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 4 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2>
struct XorpMemberCallback4B2<void, O, A1, A2, A3, A4, BA1, BA2>
: public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (O::*M)(A1, A2, A3, A4, BA1, BA2) ;
    XorpMemberCallback4B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 4 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2>
struct XorpSafeMemberCallback4B2
    : public XorpMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>::M M;
    XorpSafeMemberCallback4B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback4B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 4 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2>
struct XorpSafeMemberCallback4B2<void,O, A1, A2, A3, A4, BA1, BA2>
    : public XorpMemberCallback4B2<void, O, A1, A2, A3, A4, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback4B2<void, O, A1, A2, A3, A4, BA1, BA2>::M M;
    XorpSafeMemberCallback4B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback4B2<void, O, A1, A2, A3, A4, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback4B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback4B2<void, O, A1, A2, A3, A4, BA1, BA2>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory4B2
{
    static XorpMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2>
struct XorpMemberCallbackFactory4B2<R, O, A1, A2, A3, A4, BA1, BA2, false>
{
    static XorpMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 4 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory4B2<R,  O, A1, A2, A3, A4, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 4 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory4B2<R,  O, A1, A2, A3, A4, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 4 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2>
struct XorpConstMemberCallback4B2 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (O::*M)(A1, A2, A3, A4, BA1, BA2)  const;
    XorpConstMemberCallback4B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 4 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2>
struct XorpConstMemberCallback4B2<void, O, A1, A2, A3, A4, BA1, BA2>
: public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (O::*M)(A1, A2, A3, A4, BA1, BA2)  const;
    XorpConstMemberCallback4B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 4 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2>
struct XorpConstSafeMemberCallback4B2
    : public XorpConstMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>::M M;
    XorpConstSafeMemberCallback4B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback4B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 4 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2>
struct XorpConstSafeMemberCallback4B2<void,O, A1, A2, A3, A4, BA1, BA2>
    : public XorpConstMemberCallback4B2<void, O, A1, A2, A3, A4, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback4B2<void, O, A1, A2, A3, A4, BA1, BA2>::M M;
    XorpConstSafeMemberCallback4B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback4B2<void, O, A1, A2, A3, A4, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback4B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback4B2<void, O, A1, A2, A3, A4, BA1, BA2>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory4B2
{
    static XorpConstMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2>
struct XorpConstMemberCallbackFactory4B2<R, O, A1, A2, A3, A4, BA1, BA2, false>
{
    static XorpConstMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback4B2<R, O, A1, A2, A3, A4, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 4 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory4B2<R,  const O, A1, A2, A3, A4, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 4 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory4B2<R,  const O, A1, A2, A3, A4, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 4 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3>
struct XorpFunctionCallback4B3 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (*F)(A1, A2, A3, A4, BA1, BA2, BA3);
    XorpFunctionCallback4B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 4 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3>
struct XorpFunctionCallback4B3<void, A1, A2, A3, A4, BA1, BA2, BA3> : public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (*F)(A1, A2, A3, A4, BA1, BA2, BA3);
    XorpFunctionCallback4B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 4 dispatch time arguments and 3 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3>
typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr(new XorpFunctionCallback4B3<R, A1, A2, A3, A4, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 4 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3>
struct XorpMemberCallback4B3 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3) ;
    XorpMemberCallback4B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 4 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3>
struct XorpMemberCallback4B3<void, O, A1, A2, A3, A4, BA1, BA2, BA3>
: public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3) ;
    XorpMemberCallback4B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 4 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback4B3
    : public XorpMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback4B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback4B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 4 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback4B3<void,O, A1, A2, A3, A4, BA1, BA2, BA3>
    : public XorpMemberCallback4B3<void, O, A1, A2, A3, A4, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback4B3<void, O, A1, A2, A3, A4, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback4B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback4B3<void, O, A1, A2, A3, A4, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback4B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback4B3<void, O, A1, A2, A3, A4, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory4B3
{
    static XorpMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3, false>
{
    static XorpMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 4 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory4B3<R,  O, A1, A2, A3, A4, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 4 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory4B3<R,  O, A1, A2, A3, A4, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 4 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback4B3 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3)  const;
    XorpConstMemberCallback4B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 4 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback4B3<void, O, A1, A2, A3, A4, BA1, BA2, BA3>
: public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3)  const;
    XorpConstMemberCallback4B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 4 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback4B3
    : public XorpConstMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback4B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback4B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 4 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback4B3<void,O, A1, A2, A3, A4, BA1, BA2, BA3>
    : public XorpConstMemberCallback4B3<void, O, A1, A2, A3, A4, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback4B3<void, O, A1, A2, A3, A4, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback4B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback4B3<void, O, A1, A2, A3, A4, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback4B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback4B3<void, O, A1, A2, A3, A4, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory4B3
{
    static XorpConstMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback4B3<R, O, A1, A2, A3, A4, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 4 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory4B3<R,  const O, A1, A2, A3, A4, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 4 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory4B3<R,  const O, A1, A2, A3, A4, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 4 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback4B4 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (*F)(A1, A2, A3, A4, BA1, BA2, BA3, BA4);
    XorpFunctionCallback4B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 4 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback4B4<void, A1, A2, A3, A4, BA1, BA2, BA3, BA4> : public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (*F)(A1, A2, A3, A4, BA1, BA2, BA3, BA4);
    XorpFunctionCallback4B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 4 dispatch time arguments and 4 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr(new XorpFunctionCallback4B4<R, A1, A2, A3, A4, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 4 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback4B4 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback4B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 4 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback4B4<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>
: public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback4B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 4 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback4B4
    : public XorpMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback4B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback4B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 4 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback4B4<void,O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback4B4<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback4B4<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback4B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback4B4<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback4B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback4B4<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory4B4
{
    static XorpMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 4 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory4B4<R,  O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 4 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory4B4<R,  O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 4 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback4B4 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback4B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 4 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback4B4<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>
: public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback4B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 4 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback4B4
    : public XorpConstMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback4B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback4B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 4 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback4B4<void,O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback4B4<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback4B4<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback4B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback4B4<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback4B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback4B4<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory4B4
{
    static XorpConstMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback4B4<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 4 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory4B4<R,  const O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 4 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory4B4<R,  const O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 4 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback4B5 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (*F)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback4B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 4 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback4B5<void, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5> : public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (*F)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback4B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 4 dispatch time arguments and 5 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr(new XorpFunctionCallback4B5<R, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 4 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback4B5 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback4B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 4 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback4B5<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback4B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 4 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback4B5
    : public XorpMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback4B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback4B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 4 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback4B5<void,O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback4B5<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback4B5<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback4B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback4B5<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback4B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback4B5<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory4B5
{
    static XorpMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 4 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory4B5<R,  O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 4 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory4B5<R,  O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 4 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback4B5 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback4B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 4 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback4B5<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback4B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 4 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback4B5
    : public XorpConstMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback4B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback4B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 4 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback4B5<void,O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback4B5<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback4B5<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback4B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback4B5<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback4B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback4B5<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory4B5
{
    static XorpConstMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback4B5<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 4 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory4B5<R,  const O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 4 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory4B5<R,  const O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 4 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback4B6 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (*F)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback4B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 4 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback4B6<void, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (*F)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback4B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 4 dispatch time arguments and 6 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr(new XorpFunctionCallback4B6<R, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 4 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback4B6 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback4B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 4 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback4B6<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback4B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 4 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback4B6
    : public XorpMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback4B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback4B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 4 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback4B6<void,O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback4B6<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback4B6<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback4B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback4B6<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback4B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback4B6<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory4B6
{
    static XorpMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 4 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory4B6<R,  O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 4 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory4B6<R,  O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 4 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback4B6 : public XorpCallback4<R, A1, A2, A3, A4> {
    typedef R (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback4B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback4<R, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 4 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback4B6<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback4<void, A1, A2, A3, A4> {
    typedef void (O::*M)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback4B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback4<void, A1, A2, A3, A4>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 4 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback4B6
    : public XorpConstMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback4B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback4B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 4 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback4B6<void,O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback4B6<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback4B6<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback4B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback4B6<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback4B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback4B6<void, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory4B6
{
    static XorpConstMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback4B6<R, O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 4 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory4B6<R,  const O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 4 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback4<R, A1, A2, A3, A4>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory4B6<R,  const O, A1, A2, A3, A4, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 5 late args
//

/**
 * @short Base class for callbacks with 5 dispatch time args.
 */
template<class R, class A1, class A2, class A3, class A4, class A5>
struct XorpCallback5 {
    typedef ref_ptr<XorpCallback5> RefPtr;

    XorpCallback5(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback5() {}
    virtual R dispatch(A1, A2, A3, A4, A5) = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 5 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5>
struct XorpFunctionCallback5B0 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (*F)(A1, A2, A3, A4, A5);
    XorpFunctionCallback5B0(const char* file, int line, F f)
	: XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _f(f)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 5 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5>
struct XorpFunctionCallback5B0<void, A1, A2, A3, A4, A5> : public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (*F)(A1, A2, A3, A4, A5);
    XorpFunctionCallback5B0(const char* file, int line, F f)
	: XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _f(f)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5);
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 5 dispatch time arguments and 0 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5>
typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5)) {
    return typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr(new XorpFunctionCallback5B0<R, A1, A2, A3, A4, A5>(file, line, f));
}

/**
 * @short Callback object for member methods with 5 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5>
struct XorpMemberCallback5B0 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (O::*M)(A1, A2, A3, A4, A5) ;
    XorpMemberCallback5B0(const char* file, int line, O* o, M m)
	 : XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 5 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5>
struct XorpMemberCallback5B0<void, O, A1, A2, A3, A4, A5>
: public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (O::*M)(A1, A2, A3, A4, A5) ;
    XorpMemberCallback5B0(const char* file, int line, O* o, M m)
	 : XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 5 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5>
struct XorpSafeMemberCallback5B0
    : public XorpMemberCallback5B0<R, O, A1, A2, A3, A4, A5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback5B0<R, O, A1, A2, A3, A4, A5>::M M;
    XorpSafeMemberCallback5B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback5B0<R, O, A1, A2, A3, A4, A5>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback5B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback5B0<R, O, A1, A2, A3, A4, A5>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 5 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5>
struct XorpSafeMemberCallback5B0<void,O, A1, A2, A3, A4, A5>
    : public XorpMemberCallback5B0<void, O, A1, A2, A3, A4, A5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback5B0<void, O, A1, A2, A3, A4, A5>::M M;
    XorpSafeMemberCallback5B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback5B0<void, O, A1, A2, A3, A4, A5>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback5B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback5B0<void, O, A1, A2, A3, A4, A5>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, bool B=true>
struct XorpMemberCallbackFactory5B0
{
    static XorpMemberCallback5B0<R, O, A1, A2, A3, A4, A5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5))
    {
	return new XorpSafeMemberCallback5B0<R, O, A1, A2, A3, A4, A5>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5>
struct XorpMemberCallbackFactory5B0<R, O, A1, A2, A3, A4, A5, false>
{
    static XorpMemberCallback5B0<R, O, A1, A2, A3, A4, A5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5))
    {
	return new XorpMemberCallback5B0<R, O, A1, A2, A3, A4, A5>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 5 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5))
{
    return XorpMemberCallbackFactory5B0<R,  O, A1, A2, A3, A4, A5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 5 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5))
{
    return XorpMemberCallbackFactory5B0<R,  O, A1, A2, A3, A4, A5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 5 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5>
struct XorpConstMemberCallback5B0 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (O::*M)(A1, A2, A3, A4, A5)  const;
    XorpConstMemberCallback5B0(const char* file, int line, O* o, M m)
	 : XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 5 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5>
struct XorpConstMemberCallback5B0<void, O, A1, A2, A3, A4, A5>
: public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (O::*M)(A1, A2, A3, A4, A5)  const;
    XorpConstMemberCallback5B0(const char* file, int line, O* o, M m)
	 : XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 5 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5>
struct XorpConstSafeMemberCallback5B0
    : public XorpConstMemberCallback5B0<R, O, A1, A2, A3, A4, A5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback5B0<R, O, A1, A2, A3, A4, A5>::M M;
    XorpConstSafeMemberCallback5B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback5B0<R, O, A1, A2, A3, A4, A5>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback5B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback5B0<R, O, A1, A2, A3, A4, A5>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 5 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5>
struct XorpConstSafeMemberCallback5B0<void,O, A1, A2, A3, A4, A5>
    : public XorpConstMemberCallback5B0<void, O, A1, A2, A3, A4, A5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback5B0<void, O, A1, A2, A3, A4, A5>::M M;
    XorpConstSafeMemberCallback5B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback5B0<void, O, A1, A2, A3, A4, A5>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback5B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback5B0<void, O, A1, A2, A3, A4, A5>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, bool B=true>
struct XorpConstMemberCallbackFactory5B0
{
    static XorpConstMemberCallback5B0<R, O, A1, A2, A3, A4, A5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5) const)
    {
	return new XorpConstSafeMemberCallback5B0<R, O, A1, A2, A3, A4, A5>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5>
struct XorpConstMemberCallbackFactory5B0<R, O, A1, A2, A3, A4, A5, false>
{
    static XorpConstMemberCallback5B0<R, O, A1, A2, A3, A4, A5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5) const)
    {
	return new XorpConstMemberCallback5B0<R, O, A1, A2, A3, A4, A5>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 5 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5) const)
{
    return XorpConstMemberCallbackFactory5B0<R,  const O, A1, A2, A3, A4, A5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 5 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5) const)
{
    return XorpConstMemberCallbackFactory5B0<R,  const O, A1, A2, A3, A4, A5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 5 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class BA1>
struct XorpFunctionCallback5B1 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (*F)(A1, A2, A3, A4, A5, BA1);
    XorpFunctionCallback5B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 5 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class BA1>
struct XorpFunctionCallback5B1<void, A1, A2, A3, A4, A5, BA1> : public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (*F)(A1, A2, A3, A4, A5, BA1);
    XorpFunctionCallback5B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, _ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 5 dispatch time arguments and 1 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class BA1>
typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, BA1), BA1 ba1) {
    return typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr(new XorpFunctionCallback5B1<R, A1, A2, A3, A4, A5, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 5 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1>
struct XorpMemberCallback5B1 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, BA1) ;
    XorpMemberCallback5B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 5 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1>
struct XorpMemberCallback5B1<void, O, A1, A2, A3, A4, A5, BA1>
: public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, BA1) ;
    XorpMemberCallback5B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 5 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1>
struct XorpSafeMemberCallback5B1
    : public XorpMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>::M M;
    XorpSafeMemberCallback5B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback5B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 5 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1>
struct XorpSafeMemberCallback5B1<void,O, A1, A2, A3, A4, A5, BA1>
    : public XorpMemberCallback5B1<void, O, A1, A2, A3, A4, A5, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback5B1<void, O, A1, A2, A3, A4, A5, BA1>::M M;
    XorpSafeMemberCallback5B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback5B1<void, O, A1, A2, A3, A4, A5, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback5B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback5B1<void, O, A1, A2, A3, A4, A5, BA1>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, bool B=true>
struct XorpMemberCallbackFactory5B1
{
    static XorpMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1>
struct XorpMemberCallbackFactory5B1<R, O, A1, A2, A3, A4, A5, BA1, false>
{
    static XorpMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1), BA1 ba1)
    {
	return new XorpMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 5 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory5B1<R,  O, A1, A2, A3, A4, A5, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 5 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory5B1<R,  O, A1, A2, A3, A4, A5, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 5 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1>
struct XorpConstMemberCallback5B1 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, BA1)  const;
    XorpConstMemberCallback5B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 5 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1>
struct XorpConstMemberCallback5B1<void, O, A1, A2, A3, A4, A5, BA1>
: public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, BA1)  const;
    XorpConstMemberCallback5B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 5 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1>
struct XorpConstSafeMemberCallback5B1
    : public XorpConstMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>::M M;
    XorpConstSafeMemberCallback5B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback5B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 5 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1>
struct XorpConstSafeMemberCallback5B1<void,O, A1, A2, A3, A4, A5, BA1>
    : public XorpConstMemberCallback5B1<void, O, A1, A2, A3, A4, A5, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback5B1<void, O, A1, A2, A3, A4, A5, BA1>::M M;
    XorpConstSafeMemberCallback5B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback5B1<void, O, A1, A2, A3, A4, A5, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback5B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback5B1<void, O, A1, A2, A3, A4, A5, BA1>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory5B1
{
    static XorpConstMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1>
struct XorpConstMemberCallbackFactory5B1<R, O, A1, A2, A3, A4, A5, BA1, false>
{
    static XorpConstMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback5B1<R, O, A1, A2, A3, A4, A5, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 5 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory5B1<R,  const O, A1, A2, A3, A4, A5, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 5 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory5B1<R,  const O, A1, A2, A3, A4, A5, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 5 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2>
struct XorpFunctionCallback5B2 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (*F)(A1, A2, A3, A4, A5, BA1, BA2);
    XorpFunctionCallback5B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 5 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class BA1, class BA2>
struct XorpFunctionCallback5B2<void, A1, A2, A3, A4, A5, BA1, BA2> : public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (*F)(A1, A2, A3, A4, A5, BA1, BA2);
    XorpFunctionCallback5B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 5 dispatch time arguments and 2 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2>
typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr(new XorpFunctionCallback5B2<R, A1, A2, A3, A4, A5, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 5 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2>
struct XorpMemberCallback5B2 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, BA1, BA2) ;
    XorpMemberCallback5B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 5 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2>
struct XorpMemberCallback5B2<void, O, A1, A2, A3, A4, A5, BA1, BA2>
: public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, BA1, BA2) ;
    XorpMemberCallback5B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 5 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2>
struct XorpSafeMemberCallback5B2
    : public XorpMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>::M M;
    XorpSafeMemberCallback5B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback5B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 5 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2>
struct XorpSafeMemberCallback5B2<void,O, A1, A2, A3, A4, A5, BA1, BA2>
    : public XorpMemberCallback5B2<void, O, A1, A2, A3, A4, A5, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback5B2<void, O, A1, A2, A3, A4, A5, BA1, BA2>::M M;
    XorpSafeMemberCallback5B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback5B2<void, O, A1, A2, A3, A4, A5, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback5B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback5B2<void, O, A1, A2, A3, A4, A5, BA1, BA2>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory5B2
{
    static XorpMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2>
struct XorpMemberCallbackFactory5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2, false>
{
    static XorpMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 5 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory5B2<R,  O, A1, A2, A3, A4, A5, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 5 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory5B2<R,  O, A1, A2, A3, A4, A5, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 5 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2>
struct XorpConstMemberCallback5B2 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, BA1, BA2)  const;
    XorpConstMemberCallback5B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 5 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2>
struct XorpConstMemberCallback5B2<void, O, A1, A2, A3, A4, A5, BA1, BA2>
: public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, BA1, BA2)  const;
    XorpConstMemberCallback5B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 5 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2>
struct XorpConstSafeMemberCallback5B2
    : public XorpConstMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>::M M;
    XorpConstSafeMemberCallback5B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback5B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 5 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2>
struct XorpConstSafeMemberCallback5B2<void,O, A1, A2, A3, A4, A5, BA1, BA2>
    : public XorpConstMemberCallback5B2<void, O, A1, A2, A3, A4, A5, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback5B2<void, O, A1, A2, A3, A4, A5, BA1, BA2>::M M;
    XorpConstSafeMemberCallback5B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback5B2<void, O, A1, A2, A3, A4, A5, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback5B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback5B2<void, O, A1, A2, A3, A4, A5, BA1, BA2>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory5B2
{
    static XorpConstMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2>
struct XorpConstMemberCallbackFactory5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2, false>
{
    static XorpConstMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback5B2<R, O, A1, A2, A3, A4, A5, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 5 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory5B2<R,  const O, A1, A2, A3, A4, A5, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 5 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory5B2<R,  const O, A1, A2, A3, A4, A5, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 5 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3>
struct XorpFunctionCallback5B3 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (*F)(A1, A2, A3, A4, A5, BA1, BA2, BA3);
    XorpFunctionCallback5B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 5 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3>
struct XorpFunctionCallback5B3<void, A1, A2, A3, A4, A5, BA1, BA2, BA3> : public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (*F)(A1, A2, A3, A4, A5, BA1, BA2, BA3);
    XorpFunctionCallback5B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 5 dispatch time arguments and 3 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3>
typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr(new XorpFunctionCallback5B3<R, A1, A2, A3, A4, A5, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 5 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3>
struct XorpMemberCallback5B3 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3) ;
    XorpMemberCallback5B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 5 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3>
struct XorpMemberCallback5B3<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>
: public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3) ;
    XorpMemberCallback5B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 5 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback5B3
    : public XorpMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback5B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback5B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 5 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback5B3<void,O, A1, A2, A3, A4, A5, BA1, BA2, BA3>
    : public XorpMemberCallback5B3<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback5B3<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback5B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback5B3<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback5B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback5B3<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory5B3
{
    static XorpMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, false>
{
    static XorpMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 5 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory5B3<R,  O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 5 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory5B3<R,  O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 5 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback5B3 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3)  const;
    XorpConstMemberCallback5B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 5 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback5B3<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>
: public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3)  const;
    XorpConstMemberCallback5B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 5 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback5B3
    : public XorpConstMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback5B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback5B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 5 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback5B3<void,O, A1, A2, A3, A4, A5, BA1, BA2, BA3>
    : public XorpConstMemberCallback5B3<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback5B3<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback5B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback5B3<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback5B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback5B3<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory5B3
{
    static XorpConstMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback5B3<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 5 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory5B3<R,  const O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 5 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory5B3<R,  const O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 5 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback5B4 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (*F)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4);
    XorpFunctionCallback5B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 5 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback5B4<void, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4> : public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (*F)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4);
    XorpFunctionCallback5B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 5 dispatch time arguments and 4 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr(new XorpFunctionCallback5B4<R, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 5 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback5B4 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback5B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 5 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback5B4<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>
: public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback5B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 5 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback5B4
    : public XorpMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback5B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback5B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 5 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback5B4<void,O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback5B4<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback5B4<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback5B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback5B4<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback5B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback5B4<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory5B4
{
    static XorpMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 5 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory5B4<R,  O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 5 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory5B4<R,  O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 5 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback5B4 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback5B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 5 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback5B4<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>
: public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback5B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 5 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback5B4
    : public XorpConstMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback5B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback5B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 5 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback5B4<void,O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback5B4<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback5B4<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback5B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback5B4<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback5B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback5B4<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory5B4
{
    static XorpConstMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback5B4<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 5 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory5B4<R,  const O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 5 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory5B4<R,  const O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 5 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback5B5 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (*F)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback5B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 5 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback5B5<void, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5> : public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (*F)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback5B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 5 dispatch time arguments and 5 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr(new XorpFunctionCallback5B5<R, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 5 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback5B5 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback5B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 5 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback5B5<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback5B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 5 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback5B5
    : public XorpMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback5B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback5B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 5 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback5B5<void,O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback5B5<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback5B5<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback5B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback5B5<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback5B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback5B5<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory5B5
{
    static XorpMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 5 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory5B5<R,  O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 5 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory5B5<R,  O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 5 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback5B5 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback5B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 5 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback5B5<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback5B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 5 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback5B5
    : public XorpConstMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback5B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback5B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 5 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback5B5<void,O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback5B5<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback5B5<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback5B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback5B5<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback5B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback5B5<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory5B5
{
    static XorpConstMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback5B5<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 5 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory5B5<R,  const O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 5 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory5B5<R,  const O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 5 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback5B6 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (*F)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback5B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 5 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback5B6<void, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (*F)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback5B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 5 dispatch time arguments and 6 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr(new XorpFunctionCallback5B6<R, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 5 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback5B6 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback5B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 5 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback5B6<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback5B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 5 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback5B6
    : public XorpMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback5B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback5B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 5 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback5B6<void,O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback5B6<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback5B6<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback5B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback5B6<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback5B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback5B6<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory5B6
{
    static XorpMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 5 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory5B6<R,  O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 5 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory5B6<R,  O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 5 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback5B6 : public XorpCallback5<R, A1, A2, A3, A4, A5> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback5B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback5<R, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 5 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback5B6<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback5<void, A1, A2, A3, A4, A5> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback5B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback5<void, A1, A2, A3, A4, A5>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 5 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback5B6
    : public XorpConstMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback5B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback5B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 5 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback5B6<void,O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback5B6<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback5B6<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback5B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback5B6<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback5B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback5B6<void, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory5B6
{
    static XorpConstMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback5B6<R, O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 5 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory5B6<R,  const O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 5 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback5<R, A1, A2, A3, A4, A5>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory5B6<R,  const O, A1, A2, A3, A4, A5, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 6 late args
//

/**
 * @short Base class for callbacks with 6 dispatch time args.
 */
template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
struct XorpCallback6 {
    typedef ref_ptr<XorpCallback6> RefPtr;

    XorpCallback6(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback6() {}
    virtual R dispatch(A1, A2, A3, A4, A5, A6) = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 6 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
struct XorpFunctionCallback6B0 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6);
    XorpFunctionCallback6B0(const char* file, int line, F f)
	: XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _f(f)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 6 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6>
struct XorpFunctionCallback6B0<void, A1, A2, A3, A4, A5, A6> : public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6);
    XorpFunctionCallback6B0(const char* file, int line, F f)
	: XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _f(f)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6);
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 6 dispatch time arguments and 0 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6)) {
    return typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr(new XorpFunctionCallback6B0<R, A1, A2, A3, A4, A5, A6>(file, line, f));
}

/**
 * @short Callback object for member methods with 6 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6>
struct XorpMemberCallback6B0 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6) ;
    XorpMemberCallback6B0(const char* file, int line, O* o, M m)
	 : XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 6 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6>
struct XorpMemberCallback6B0<void, O, A1, A2, A3, A4, A5, A6>
: public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6) ;
    XorpMemberCallback6B0(const char* file, int line, O* o, M m)
	 : XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 6 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6>
struct XorpSafeMemberCallback6B0
    : public XorpMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>::M M;
    XorpSafeMemberCallback6B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback6B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 6 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6>
struct XorpSafeMemberCallback6B0<void,O, A1, A2, A3, A4, A5, A6>
    : public XorpMemberCallback6B0<void, O, A1, A2, A3, A4, A5, A6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback6B0<void, O, A1, A2, A3, A4, A5, A6>::M M;
    XorpSafeMemberCallback6B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback6B0<void, O, A1, A2, A3, A4, A5, A6>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback6B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback6B0<void, O, A1, A2, A3, A4, A5, A6>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, bool B=true>
struct XorpMemberCallbackFactory6B0
{
    static XorpMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6))
    {
	return new XorpSafeMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6>
struct XorpMemberCallbackFactory6B0<R, O, A1, A2, A3, A4, A5, A6, false>
{
    static XorpMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6))
    {
	return new XorpMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 6 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6))
{
    return XorpMemberCallbackFactory6B0<R,  O, A1, A2, A3, A4, A5, A6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 6 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6))
{
    return XorpMemberCallbackFactory6B0<R,  O, A1, A2, A3, A4, A5, A6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 6 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6>
struct XorpConstMemberCallback6B0 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6)  const;
    XorpConstMemberCallback6B0(const char* file, int line, O* o, M m)
	 : XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 6 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6>
struct XorpConstMemberCallback6B0<void, O, A1, A2, A3, A4, A5, A6>
: public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6)  const;
    XorpConstMemberCallback6B0(const char* file, int line, O* o, M m)
	 : XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 6 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6>
struct XorpConstSafeMemberCallback6B0
    : public XorpConstMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>::M M;
    XorpConstSafeMemberCallback6B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback6B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 6 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6>
struct XorpConstSafeMemberCallback6B0<void,O, A1, A2, A3, A4, A5, A6>
    : public XorpConstMemberCallback6B0<void, O, A1, A2, A3, A4, A5, A6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback6B0<void, O, A1, A2, A3, A4, A5, A6>::M M;
    XorpConstSafeMemberCallback6B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback6B0<void, O, A1, A2, A3, A4, A5, A6>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback6B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback6B0<void, O, A1, A2, A3, A4, A5, A6>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, bool B=true>
struct XorpConstMemberCallbackFactory6B0
{
    static XorpConstMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6) const)
    {
	return new XorpConstSafeMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6>
struct XorpConstMemberCallbackFactory6B0<R, O, A1, A2, A3, A4, A5, A6, false>
{
    static XorpConstMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6) const)
    {
	return new XorpConstMemberCallback6B0<R, O, A1, A2, A3, A4, A5, A6>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 6 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6) const)
{
    return XorpConstMemberCallbackFactory6B0<R,  const O, A1, A2, A3, A4, A5, A6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 6 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6) const)
{
    return XorpConstMemberCallbackFactory6B0<R,  const O, A1, A2, A3, A4, A5, A6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 6 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1>
struct XorpFunctionCallback6B1 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, BA1);
    XorpFunctionCallback6B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 6 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class BA1>
struct XorpFunctionCallback6B1<void, A1, A2, A3, A4, A5, A6, BA1> : public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, BA1);
    XorpFunctionCallback6B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, _ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 6 dispatch time arguments and 1 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1>
typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, BA1), BA1 ba1) {
    return typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr(new XorpFunctionCallback6B1<R, A1, A2, A3, A4, A5, A6, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 6 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1>
struct XorpMemberCallback6B1 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, BA1) ;
    XorpMemberCallback6B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 6 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1>
struct XorpMemberCallback6B1<void, O, A1, A2, A3, A4, A5, A6, BA1>
: public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, BA1) ;
    XorpMemberCallback6B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 6 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1>
struct XorpSafeMemberCallback6B1
    : public XorpMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>::M M;
    XorpSafeMemberCallback6B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback6B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 6 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1>
struct XorpSafeMemberCallback6B1<void,O, A1, A2, A3, A4, A5, A6, BA1>
    : public XorpMemberCallback6B1<void, O, A1, A2, A3, A4, A5, A6, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback6B1<void, O, A1, A2, A3, A4, A5, A6, BA1>::M M;
    XorpSafeMemberCallback6B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback6B1<void, O, A1, A2, A3, A4, A5, A6, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback6B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback6B1<void, O, A1, A2, A3, A4, A5, A6, BA1>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, bool B=true>
struct XorpMemberCallbackFactory6B1
{
    static XorpMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1>
struct XorpMemberCallbackFactory6B1<R, O, A1, A2, A3, A4, A5, A6, BA1, false>
{
    static XorpMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1), BA1 ba1)
    {
	return new XorpMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 6 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory6B1<R,  O, A1, A2, A3, A4, A5, A6, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 6 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory6B1<R,  O, A1, A2, A3, A4, A5, A6, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 6 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1>
struct XorpConstMemberCallback6B1 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, BA1)  const;
    XorpConstMemberCallback6B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 6 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1>
struct XorpConstMemberCallback6B1<void, O, A1, A2, A3, A4, A5, A6, BA1>
: public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, BA1)  const;
    XorpConstMemberCallback6B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 6 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1>
struct XorpConstSafeMemberCallback6B1
    : public XorpConstMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>::M M;
    XorpConstSafeMemberCallback6B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback6B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 6 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1>
struct XorpConstSafeMemberCallback6B1<void,O, A1, A2, A3, A4, A5, A6, BA1>
    : public XorpConstMemberCallback6B1<void, O, A1, A2, A3, A4, A5, A6, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback6B1<void, O, A1, A2, A3, A4, A5, A6, BA1>::M M;
    XorpConstSafeMemberCallback6B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback6B1<void, O, A1, A2, A3, A4, A5, A6, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback6B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback6B1<void, O, A1, A2, A3, A4, A5, A6, BA1>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory6B1
{
    static XorpConstMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1>
struct XorpConstMemberCallbackFactory6B1<R, O, A1, A2, A3, A4, A5, A6, BA1, false>
{
    static XorpConstMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback6B1<R, O, A1, A2, A3, A4, A5, A6, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 6 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory6B1<R,  const O, A1, A2, A3, A4, A5, A6, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 6 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory6B1<R,  const O, A1, A2, A3, A4, A5, A6, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 6 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2>
struct XorpFunctionCallback6B2 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, BA1, BA2);
    XorpFunctionCallback6B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 6 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2>
struct XorpFunctionCallback6B2<void, A1, A2, A3, A4, A5, A6, BA1, BA2> : public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, BA1, BA2);
    XorpFunctionCallback6B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 6 dispatch time arguments and 2 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2>
typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr(new XorpFunctionCallback6B2<R, A1, A2, A3, A4, A5, A6, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 6 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2>
struct XorpMemberCallback6B2 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2) ;
    XorpMemberCallback6B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 6 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2>
struct XorpMemberCallback6B2<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2>
: public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2) ;
    XorpMemberCallback6B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 6 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2>
struct XorpSafeMemberCallback6B2
    : public XorpMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>::M M;
    XorpSafeMemberCallback6B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback6B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 6 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2>
struct XorpSafeMemberCallback6B2<void,O, A1, A2, A3, A4, A5, A6, BA1, BA2>
    : public XorpMemberCallback6B2<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback6B2<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2>::M M;
    XorpSafeMemberCallback6B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback6B2<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback6B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback6B2<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory6B2
{
    static XorpMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2>
struct XorpMemberCallbackFactory6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, false>
{
    static XorpMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 6 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory6B2<R,  O, A1, A2, A3, A4, A5, A6, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 6 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory6B2<R,  O, A1, A2, A3, A4, A5, A6, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 6 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2>
struct XorpConstMemberCallback6B2 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2)  const;
    XorpConstMemberCallback6B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 6 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2>
struct XorpConstMemberCallback6B2<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2>
: public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2)  const;
    XorpConstMemberCallback6B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 6 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2>
struct XorpConstSafeMemberCallback6B2
    : public XorpConstMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>::M M;
    XorpConstSafeMemberCallback6B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback6B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 6 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2>
struct XorpConstSafeMemberCallback6B2<void,O, A1, A2, A3, A4, A5, A6, BA1, BA2>
    : public XorpConstMemberCallback6B2<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback6B2<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2>::M M;
    XorpConstSafeMemberCallback6B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback6B2<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback6B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback6B2<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory6B2
{
    static XorpConstMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2>
struct XorpConstMemberCallbackFactory6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, false>
{
    static XorpConstMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback6B2<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 6 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory6B2<R,  const O, A1, A2, A3, A4, A5, A6, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 6 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory6B2<R,  const O, A1, A2, A3, A4, A5, A6, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 6 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3>
struct XorpFunctionCallback6B3 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3);
    XorpFunctionCallback6B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 6 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3>
struct XorpFunctionCallback6B3<void, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3> : public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3);
    XorpFunctionCallback6B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 6 dispatch time arguments and 3 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3>
typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr(new XorpFunctionCallback6B3<R, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 6 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3>
struct XorpMemberCallback6B3 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3) ;
    XorpMemberCallback6B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 6 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3>
struct XorpMemberCallback6B3<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>
: public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3) ;
    XorpMemberCallback6B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 6 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback6B3
    : public XorpMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback6B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback6B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 6 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback6B3<void,O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>
    : public XorpMemberCallback6B3<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback6B3<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback6B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback6B3<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback6B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback6B3<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory6B3
{
    static XorpMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, false>
{
    static XorpMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 6 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory6B3<R,  O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 6 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory6B3<R,  O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 6 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback6B3 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3)  const;
    XorpConstMemberCallback6B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 6 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback6B3<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>
: public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3)  const;
    XorpConstMemberCallback6B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 6 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback6B3
    : public XorpConstMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback6B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback6B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 6 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback6B3<void,O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>
    : public XorpConstMemberCallback6B3<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback6B3<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback6B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback6B3<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback6B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback6B3<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory6B3
{
    static XorpConstMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback6B3<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 6 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory6B3<R,  const O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 6 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory6B3<R,  const O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 6 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback6B4 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4);
    XorpFunctionCallback6B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 6 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback6B4<void, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4> : public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4);
    XorpFunctionCallback6B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 6 dispatch time arguments and 4 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr(new XorpFunctionCallback6B4<R, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 6 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback6B4 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback6B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 6 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback6B4<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>
: public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback6B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 6 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback6B4
    : public XorpMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback6B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback6B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 6 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback6B4<void,O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback6B4<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback6B4<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback6B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback6B4<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback6B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback6B4<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory6B4
{
    static XorpMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 6 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory6B4<R,  O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 6 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory6B4<R,  O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 6 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback6B4 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback6B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 6 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback6B4<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>
: public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback6B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 6 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback6B4
    : public XorpConstMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback6B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback6B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 6 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback6B4<void,O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback6B4<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback6B4<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback6B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback6B4<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback6B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback6B4<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory6B4
{
    static XorpConstMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback6B4<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 6 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory6B4<R,  const O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 6 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory6B4<R,  const O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 6 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback6B5 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback6B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 6 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback6B5<void, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5> : public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback6B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 6 dispatch time arguments and 5 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr(new XorpFunctionCallback6B5<R, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 6 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback6B5 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback6B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 6 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback6B5<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback6B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 6 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback6B5
    : public XorpMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback6B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback6B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 6 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback6B5<void,O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback6B5<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback6B5<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback6B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback6B5<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback6B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback6B5<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory6B5
{
    static XorpMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 6 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory6B5<R,  O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 6 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory6B5<R,  O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 6 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback6B5 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback6B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 6 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback6B5<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback6B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 6 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback6B5
    : public XorpConstMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback6B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback6B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 6 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback6B5<void,O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback6B5<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback6B5<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback6B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback6B5<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback6B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback6B5<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory6B5
{
    static XorpConstMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback6B5<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 6 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory6B5<R,  const O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 6 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory6B5<R,  const O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 6 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback6B6 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback6B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 6 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback6B6<void, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback6B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 6 dispatch time arguments and 6 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr(new XorpFunctionCallback6B6<R, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 6 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback6B6 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback6B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 6 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback6B6<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback6B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 6 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback6B6
    : public XorpMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback6B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback6B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 6 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback6B6<void,O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback6B6<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback6B6<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback6B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback6B6<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback6B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback6B6<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory6B6
{
    static XorpMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 6 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory6B6<R,  O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 6 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory6B6<R,  O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 6 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback6B6 : public XorpCallback6<R, A1, A2, A3, A4, A5, A6> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback6B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback6<R, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 6 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback6B6<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback6<void, A1, A2, A3, A4, A5, A6> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback6B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback6<void, A1, A2, A3, A4, A5, A6>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 6 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback6B6
    : public XorpConstMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback6B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback6B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 6 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback6B6<void,O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback6B6<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback6B6<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback6B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback6B6<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback6B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback6B6<void, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory6B6
{
    static XorpConstMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback6B6<R, O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 6 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory6B6<R,  const O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 6 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback6<R, A1, A2, A3, A4, A5, A6>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory6B6<R,  const O, A1, A2, A3, A4, A5, A6, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 7 late args
//

/**
 * @short Base class for callbacks with 7 dispatch time args.
 */
template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
struct XorpCallback7 {
    typedef ref_ptr<XorpCallback7> RefPtr;

    XorpCallback7(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback7() {}
    virtual R dispatch(A1, A2, A3, A4, A5, A6, A7) = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 7 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
struct XorpFunctionCallback7B0 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7);
    XorpFunctionCallback7B0(const char* file, int line, F f)
	: XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _f(f)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 7 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
struct XorpFunctionCallback7B0<void, A1, A2, A3, A4, A5, A6, A7> : public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7);
    XorpFunctionCallback7B0(const char* file, int line, F f)
	: XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _f(f)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7);
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 7 dispatch time arguments and 0 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7)) {
    return typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr(new XorpFunctionCallback7B0<R, A1, A2, A3, A4, A5, A6, A7>(file, line, f));
}

/**
 * @short Callback object for member methods with 7 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
struct XorpMemberCallback7B0 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7) ;
    XorpMemberCallback7B0(const char* file, int line, O* o, M m)
	 : XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 7 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
struct XorpMemberCallback7B0<void, O, A1, A2, A3, A4, A5, A6, A7>
: public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7) ;
    XorpMemberCallback7B0(const char* file, int line, O* o, M m)
	 : XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 7 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
struct XorpSafeMemberCallback7B0
    : public XorpMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>::M M;
    XorpSafeMemberCallback7B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback7B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 7 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
struct XorpSafeMemberCallback7B0<void,O, A1, A2, A3, A4, A5, A6, A7>
    : public XorpMemberCallback7B0<void, O, A1, A2, A3, A4, A5, A6, A7>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback7B0<void, O, A1, A2, A3, A4, A5, A6, A7>::M M;
    XorpSafeMemberCallback7B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback7B0<void, O, A1, A2, A3, A4, A5, A6, A7>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback7B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback7B0<void, O, A1, A2, A3, A4, A5, A6, A7>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, bool B=true>
struct XorpMemberCallbackFactory7B0
{
    static XorpMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7))
    {
	return new XorpSafeMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
struct XorpMemberCallbackFactory7B0<R, O, A1, A2, A3, A4, A5, A6, A7, false>
{
    static XorpMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7))
    {
	return new XorpMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 7 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7))
{
    return XorpMemberCallbackFactory7B0<R,  O, A1, A2, A3, A4, A5, A6, A7, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 7 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7))
{
    return XorpMemberCallbackFactory7B0<R,  O, A1, A2, A3, A4, A5, A6, A7, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 7 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
struct XorpConstMemberCallback7B0 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7)  const;
    XorpConstMemberCallback7B0(const char* file, int line, O* o, M m)
	 : XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 7 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
struct XorpConstMemberCallback7B0<void, O, A1, A2, A3, A4, A5, A6, A7>
: public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7)  const;
    XorpConstMemberCallback7B0(const char* file, int line, O* o, M m)
	 : XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 7 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
struct XorpConstSafeMemberCallback7B0
    : public XorpConstMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>::M M;
    XorpConstSafeMemberCallback7B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback7B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 7 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
struct XorpConstSafeMemberCallback7B0<void,O, A1, A2, A3, A4, A5, A6, A7>
    : public XorpConstMemberCallback7B0<void, O, A1, A2, A3, A4, A5, A6, A7>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback7B0<void, O, A1, A2, A3, A4, A5, A6, A7>::M M;
    XorpConstSafeMemberCallback7B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback7B0<void, O, A1, A2, A3, A4, A5, A6, A7>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback7B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback7B0<void, O, A1, A2, A3, A4, A5, A6, A7>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, bool B=true>
struct XorpConstMemberCallbackFactory7B0
{
    static XorpConstMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7) const)
    {
	return new XorpConstSafeMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
struct XorpConstMemberCallbackFactory7B0<R, O, A1, A2, A3, A4, A5, A6, A7, false>
{
    static XorpConstMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7) const)
    {
	return new XorpConstMemberCallback7B0<R, O, A1, A2, A3, A4, A5, A6, A7>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 7 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7) const)
{
    return XorpConstMemberCallbackFactory7B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 7 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7) const)
{
    return XorpConstMemberCallbackFactory7B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 7 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1>
struct XorpFunctionCallback7B1 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, BA1);
    XorpFunctionCallback7B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 7 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1>
struct XorpFunctionCallback7B1<void, A1, A2, A3, A4, A5, A6, A7, BA1> : public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, BA1);
    XorpFunctionCallback7B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, _ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 7 dispatch time arguments and 1 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1>
typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, BA1), BA1 ba1) {
    return typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr(new XorpFunctionCallback7B1<R, A1, A2, A3, A4, A5, A6, A7, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 7 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1>
struct XorpMemberCallback7B1 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1) ;
    XorpMemberCallback7B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 7 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1>
struct XorpMemberCallback7B1<void, O, A1, A2, A3, A4, A5, A6, A7, BA1>
: public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1) ;
    XorpMemberCallback7B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 7 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1>
struct XorpSafeMemberCallback7B1
    : public XorpMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>::M M;
    XorpSafeMemberCallback7B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback7B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 7 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1>
struct XorpSafeMemberCallback7B1<void,O, A1, A2, A3, A4, A5, A6, A7, BA1>
    : public XorpMemberCallback7B1<void, O, A1, A2, A3, A4, A5, A6, A7, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback7B1<void, O, A1, A2, A3, A4, A5, A6, A7, BA1>::M M;
    XorpSafeMemberCallback7B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback7B1<void, O, A1, A2, A3, A4, A5, A6, A7, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback7B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback7B1<void, O, A1, A2, A3, A4, A5, A6, A7, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, bool B=true>
struct XorpMemberCallbackFactory7B1
{
    static XorpMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1>
struct XorpMemberCallbackFactory7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, false>
{
    static XorpMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1), BA1 ba1)
    {
	return new XorpMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 7 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory7B1<R,  O, A1, A2, A3, A4, A5, A6, A7, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 7 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory7B1<R,  O, A1, A2, A3, A4, A5, A6, A7, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 7 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1>
struct XorpConstMemberCallback7B1 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1)  const;
    XorpConstMemberCallback7B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 7 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1>
struct XorpConstMemberCallback7B1<void, O, A1, A2, A3, A4, A5, A6, A7, BA1>
: public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1)  const;
    XorpConstMemberCallback7B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 7 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1>
struct XorpConstSafeMemberCallback7B1
    : public XorpConstMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>::M M;
    XorpConstSafeMemberCallback7B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback7B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 7 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1>
struct XorpConstSafeMemberCallback7B1<void,O, A1, A2, A3, A4, A5, A6, A7, BA1>
    : public XorpConstMemberCallback7B1<void, O, A1, A2, A3, A4, A5, A6, A7, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback7B1<void, O, A1, A2, A3, A4, A5, A6, A7, BA1>::M M;
    XorpConstSafeMemberCallback7B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback7B1<void, O, A1, A2, A3, A4, A5, A6, A7, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback7B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback7B1<void, O, A1, A2, A3, A4, A5, A6, A7, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory7B1
{
    static XorpConstMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1>
struct XorpConstMemberCallbackFactory7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, false>
{
    static XorpConstMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback7B1<R, O, A1, A2, A3, A4, A5, A6, A7, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 7 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory7B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 7 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory7B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 7 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2>
struct XorpFunctionCallback7B2 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2);
    XorpFunctionCallback7B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 7 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2>
struct XorpFunctionCallback7B2<void, A1, A2, A3, A4, A5, A6, A7, BA1, BA2> : public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2);
    XorpFunctionCallback7B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 7 dispatch time arguments and 2 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2>
typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr(new XorpFunctionCallback7B2<R, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 7 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2>
struct XorpMemberCallback7B2 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2) ;
    XorpMemberCallback7B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 7 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2>
struct XorpMemberCallback7B2<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>
: public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2) ;
    XorpMemberCallback7B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 7 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2>
struct XorpSafeMemberCallback7B2
    : public XorpMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>::M M;
    XorpSafeMemberCallback7B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback7B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 7 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2>
struct XorpSafeMemberCallback7B2<void,O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>
    : public XorpMemberCallback7B2<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback7B2<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>::M M;
    XorpSafeMemberCallback7B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback7B2<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback7B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback7B2<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory7B2
{
    static XorpMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2>
struct XorpMemberCallbackFactory7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, false>
{
    static XorpMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 7 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory7B2<R,  O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 7 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory7B2<R,  O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 7 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2>
struct XorpConstMemberCallback7B2 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2)  const;
    XorpConstMemberCallback7B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 7 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2>
struct XorpConstMemberCallback7B2<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>
: public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2)  const;
    XorpConstMemberCallback7B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 7 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2>
struct XorpConstSafeMemberCallback7B2
    : public XorpConstMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>::M M;
    XorpConstSafeMemberCallback7B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback7B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 7 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2>
struct XorpConstSafeMemberCallback7B2<void,O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>
    : public XorpConstMemberCallback7B2<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback7B2<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>::M M;
    XorpConstSafeMemberCallback7B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback7B2<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback7B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback7B2<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory7B2
{
    static XorpConstMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2>
struct XorpConstMemberCallbackFactory7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, false>
{
    static XorpConstMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback7B2<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 7 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory7B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 7 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory7B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 7 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3>
struct XorpFunctionCallback7B3 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3);
    XorpFunctionCallback7B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 7 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3>
struct XorpFunctionCallback7B3<void, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3> : public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3);
    XorpFunctionCallback7B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 7 dispatch time arguments and 3 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3>
typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr(new XorpFunctionCallback7B3<R, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 7 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3>
struct XorpMemberCallback7B3 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3) ;
    XorpMemberCallback7B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 7 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3>
struct XorpMemberCallback7B3<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>
: public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3) ;
    XorpMemberCallback7B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 7 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback7B3
    : public XorpMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback7B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback7B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 7 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback7B3<void,O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>
    : public XorpMemberCallback7B3<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback7B3<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback7B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback7B3<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback7B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback7B3<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory7B3
{
    static XorpMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, false>
{
    static XorpMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 7 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory7B3<R,  O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 7 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory7B3<R,  O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 7 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback7B3 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3)  const;
    XorpConstMemberCallback7B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 7 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback7B3<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>
: public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3)  const;
    XorpConstMemberCallback7B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 7 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback7B3
    : public XorpConstMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback7B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback7B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 7 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback7B3<void,O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>
    : public XorpConstMemberCallback7B3<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback7B3<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback7B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback7B3<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback7B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback7B3<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory7B3
{
    static XorpConstMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback7B3<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 7 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory7B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 7 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory7B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 7 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback7B4 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4);
    XorpFunctionCallback7B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 7 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback7B4<void, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4> : public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4);
    XorpFunctionCallback7B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 7 dispatch time arguments and 4 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr(new XorpFunctionCallback7B4<R, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 7 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback7B4 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback7B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 7 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback7B4<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>
: public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback7B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 7 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback7B4
    : public XorpMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback7B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback7B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 7 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback7B4<void,O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback7B4<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback7B4<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback7B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback7B4<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback7B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback7B4<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory7B4
{
    static XorpMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 7 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory7B4<R,  O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 7 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory7B4<R,  O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 7 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback7B4 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback7B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 7 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback7B4<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>
: public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback7B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 7 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback7B4
    : public XorpConstMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback7B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback7B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 7 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback7B4<void,O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback7B4<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback7B4<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback7B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback7B4<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback7B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback7B4<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory7B4
{
    static XorpConstMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback7B4<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 7 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory7B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 7 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory7B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 7 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback7B5 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback7B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 7 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback7B5<void, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5> : public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback7B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 7 dispatch time arguments and 5 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr(new XorpFunctionCallback7B5<R, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 7 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback7B5 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback7B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 7 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback7B5<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback7B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 7 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback7B5
    : public XorpMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback7B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback7B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 7 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback7B5<void,O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback7B5<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback7B5<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback7B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback7B5<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback7B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback7B5<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory7B5
{
    static XorpMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 7 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory7B5<R,  O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 7 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory7B5<R,  O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 7 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback7B5 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback7B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 7 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback7B5<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback7B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 7 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback7B5
    : public XorpConstMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback7B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback7B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 7 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback7B5<void,O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback7B5<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback7B5<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback7B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback7B5<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback7B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback7B5<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory7B5
{
    static XorpConstMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback7B5<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 7 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory7B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 7 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory7B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 7 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback7B6 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback7B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 7 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback7B6<void, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback7B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 7 dispatch time arguments and 6 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr(new XorpFunctionCallback7B6<R, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 7 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback7B6 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback7B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 7 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback7B6<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback7B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 7 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback7B6
    : public XorpMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback7B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback7B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 7 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback7B6<void,O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback7B6<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback7B6<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback7B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback7B6<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback7B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback7B6<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory7B6
{
    static XorpMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 7 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory7B6<R,  O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 7 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory7B6<R,  O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 7 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback7B6 : public XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback7B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 7 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback7B6<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback7B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback7<void, A1, A2, A3, A4, A5, A6, A7>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 7 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback7B6
    : public XorpConstMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback7B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback7B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 7 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback7B6<void,O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback7B6<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback7B6<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback7B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback7B6<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback7B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback7B6<void, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory7B6
{
    static XorpConstMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback7B6<R, O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 7 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory7B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 7 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback7<R, A1, A2, A3, A4, A5, A6, A7>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory7B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 8 late args
//

/**
 * @short Base class for callbacks with 8 dispatch time args.
 */
template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
struct XorpCallback8 {
    typedef ref_ptr<XorpCallback8> RefPtr;

    XorpCallback8(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback8() {}
    virtual R dispatch(A1, A2, A3, A4, A5, A6, A7, A8) = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 8 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
struct XorpFunctionCallback8B0 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8);
    XorpFunctionCallback8B0(const char* file, int line, F f)
	: XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _f(f)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 8 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
struct XorpFunctionCallback8B0<void, A1, A2, A3, A4, A5, A6, A7, A8> : public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8);
    XorpFunctionCallback8B0(const char* file, int line, F f)
	: XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _f(f)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8);
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 8 dispatch time arguments and 0 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8)) {
    return typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr(new XorpFunctionCallback8B0<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line, f));
}

/**
 * @short Callback object for member methods with 8 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
struct XorpMemberCallback8B0 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8) ;
    XorpMemberCallback8B0(const char* file, int line, O* o, M m)
	 : XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 8 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
struct XorpMemberCallback8B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8>
: public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8) ;
    XorpMemberCallback8B0(const char* file, int line, O* o, M m)
	 : XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 8 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
struct XorpSafeMemberCallback8B0
    : public XorpMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>::M M;
    XorpSafeMemberCallback8B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback8B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 8 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
struct XorpSafeMemberCallback8B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8>
    : public XorpMemberCallback8B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback8B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8>::M M;
    XorpSafeMemberCallback8B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback8B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback8B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback8B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, bool B=true>
struct XorpMemberCallbackFactory8B0
{
    static XorpMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8))
    {
	return new XorpSafeMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
struct XorpMemberCallbackFactory8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, false>
{
    static XorpMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8))
    {
	return new XorpMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 8 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8))
{
    return XorpMemberCallbackFactory8B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 8 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8))
{
    return XorpMemberCallbackFactory8B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 8 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
struct XorpConstMemberCallback8B0 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8)  const;
    XorpConstMemberCallback8B0(const char* file, int line, O* o, M m)
	 : XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 8 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
struct XorpConstMemberCallback8B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8>
: public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8)  const;
    XorpConstMemberCallback8B0(const char* file, int line, O* o, M m)
	 : XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 8 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
struct XorpConstSafeMemberCallback8B0
    : public XorpConstMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>::M M;
    XorpConstSafeMemberCallback8B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback8B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 8 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
struct XorpConstSafeMemberCallback8B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8>
    : public XorpConstMemberCallback8B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback8B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8>::M M;
    XorpConstSafeMemberCallback8B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback8B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback8B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback8B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, bool B=true>
struct XorpConstMemberCallbackFactory8B0
{
    static XorpConstMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8) const)
    {
	return new XorpConstSafeMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
struct XorpConstMemberCallbackFactory8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, false>
{
    static XorpConstMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8) const)
    {
	return new XorpConstMemberCallback8B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 8 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8) const)
{
    return XorpConstMemberCallbackFactory8B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 8 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8) const)
{
    return XorpConstMemberCallbackFactory8B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 8 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1>
struct XorpFunctionCallback8B1 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, BA1);
    XorpFunctionCallback8B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 8 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1>
struct XorpFunctionCallback8B1<void, A1, A2, A3, A4, A5, A6, A7, A8, BA1> : public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, BA1);
    XorpFunctionCallback8B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 8 dispatch time arguments and 1 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1>
typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, BA1), BA1 ba1) {
    return typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr(new XorpFunctionCallback8B1<R, A1, A2, A3, A4, A5, A6, A7, A8, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 8 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1>
struct XorpMemberCallback8B1 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1) ;
    XorpMemberCallback8B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 8 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1>
struct XorpMemberCallback8B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>
: public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1) ;
    XorpMemberCallback8B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 8 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1>
struct XorpSafeMemberCallback8B1
    : public XorpMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>::M M;
    XorpSafeMemberCallback8B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback8B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 8 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1>
struct XorpSafeMemberCallback8B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>
    : public XorpMemberCallback8B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback8B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>::M M;
    XorpSafeMemberCallback8B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback8B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback8B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback8B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, bool B=true>
struct XorpMemberCallbackFactory8B1
{
    static XorpMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1>
struct XorpMemberCallbackFactory8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, false>
{
    static XorpMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1), BA1 ba1)
    {
	return new XorpMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 8 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory8B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 8 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory8B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 8 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1>
struct XorpConstMemberCallback8B1 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1)  const;
    XorpConstMemberCallback8B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 8 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1>
struct XorpConstMemberCallback8B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>
: public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1)  const;
    XorpConstMemberCallback8B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 8 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1>
struct XorpConstSafeMemberCallback8B1
    : public XorpConstMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>::M M;
    XorpConstSafeMemberCallback8B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback8B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 8 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1>
struct XorpConstSafeMemberCallback8B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>
    : public XorpConstMemberCallback8B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback8B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>::M M;
    XorpConstSafeMemberCallback8B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback8B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback8B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback8B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory8B1
{
    static XorpConstMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1>
struct XorpConstMemberCallbackFactory8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, false>
{
    static XorpConstMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback8B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 8 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory8B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 8 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory8B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 8 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2>
struct XorpFunctionCallback8B2 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2);
    XorpFunctionCallback8B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 8 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2>
struct XorpFunctionCallback8B2<void, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2> : public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2);
    XorpFunctionCallback8B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 8 dispatch time arguments and 2 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2>
typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr(new XorpFunctionCallback8B2<R, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 8 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2>
struct XorpMemberCallback8B2 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2) ;
    XorpMemberCallback8B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 8 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2>
struct XorpMemberCallback8B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>
: public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2) ;
    XorpMemberCallback8B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 8 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2>
struct XorpSafeMemberCallback8B2
    : public XorpMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>::M M;
    XorpSafeMemberCallback8B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback8B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 8 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2>
struct XorpSafeMemberCallback8B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>
    : public XorpMemberCallback8B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback8B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>::M M;
    XorpSafeMemberCallback8B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback8B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback8B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback8B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory8B2
{
    static XorpMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2>
struct XorpMemberCallbackFactory8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, false>
{
    static XorpMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 8 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory8B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 8 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory8B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 8 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2>
struct XorpConstMemberCallback8B2 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2)  const;
    XorpConstMemberCallback8B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 8 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2>
struct XorpConstMemberCallback8B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>
: public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2)  const;
    XorpConstMemberCallback8B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 8 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2>
struct XorpConstSafeMemberCallback8B2
    : public XorpConstMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>::M M;
    XorpConstSafeMemberCallback8B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback8B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 8 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2>
struct XorpConstSafeMemberCallback8B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>
    : public XorpConstMemberCallback8B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback8B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>::M M;
    XorpConstSafeMemberCallback8B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback8B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback8B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback8B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory8B2
{
    static XorpConstMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2>
struct XorpConstMemberCallbackFactory8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, false>
{
    static XorpConstMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback8B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 8 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory8B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 8 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory8B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 8 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3>
struct XorpFunctionCallback8B3 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3);
    XorpFunctionCallback8B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 8 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3>
struct XorpFunctionCallback8B3<void, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3> : public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3);
    XorpFunctionCallback8B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 8 dispatch time arguments and 3 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3>
typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr(new XorpFunctionCallback8B3<R, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 8 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3>
struct XorpMemberCallback8B3 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3) ;
    XorpMemberCallback8B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 8 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3>
struct XorpMemberCallback8B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>
: public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3) ;
    XorpMemberCallback8B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 8 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback8B3
    : public XorpMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback8B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback8B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 8 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback8B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>
    : public XorpMemberCallback8B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback8B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback8B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback8B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback8B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback8B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory8B3
{
    static XorpMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, false>
{
    static XorpMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 8 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory8B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 8 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory8B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 8 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback8B3 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3)  const;
    XorpConstMemberCallback8B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 8 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback8B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>
: public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3)  const;
    XorpConstMemberCallback8B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 8 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback8B3
    : public XorpConstMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback8B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback8B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 8 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback8B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>
    : public XorpConstMemberCallback8B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback8B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback8B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback8B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback8B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback8B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory8B3
{
    static XorpConstMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback8B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 8 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory8B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 8 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory8B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 8 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback8B4 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4);
    XorpFunctionCallback8B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 8 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback8B4<void, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4> : public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4);
    XorpFunctionCallback8B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 8 dispatch time arguments and 4 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr(new XorpFunctionCallback8B4<R, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 8 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback8B4 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback8B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 8 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback8B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>
: public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback8B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 8 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback8B4
    : public XorpMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback8B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback8B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 8 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback8B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback8B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback8B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback8B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback8B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback8B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback8B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory8B4
{
    static XorpMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 8 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory8B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 8 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory8B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 8 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback8B4 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback8B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 8 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback8B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>
: public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback8B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 8 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback8B4
    : public XorpConstMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback8B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback8B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 8 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback8B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback8B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback8B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback8B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback8B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback8B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback8B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory8B4
{
    static XorpConstMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback8B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 8 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory8B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 8 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory8B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 8 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback8B5 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback8B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 8 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback8B5<void, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5> : public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback8B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 8 dispatch time arguments and 5 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr(new XorpFunctionCallback8B5<R, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 8 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback8B5 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback8B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 8 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback8B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback8B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 8 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback8B5
    : public XorpMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback8B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback8B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 8 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback8B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback8B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback8B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback8B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback8B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback8B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback8B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory8B5
{
    static XorpMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 8 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory8B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 8 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory8B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 8 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback8B5 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback8B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 8 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback8B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback8B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 8 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback8B5
    : public XorpConstMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback8B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback8B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 8 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback8B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback8B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback8B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback8B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback8B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback8B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback8B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory8B5
{
    static XorpConstMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback8B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 8 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory8B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 8 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory8B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 8 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback8B6 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback8B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 8 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback8B6<void, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback8B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 8 dispatch time arguments and 6 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr(new XorpFunctionCallback8B6<R, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 8 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback8B6 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback8B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 8 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback8B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback8B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 8 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback8B6
    : public XorpMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback8B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback8B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 8 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback8B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback8B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback8B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback8B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback8B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback8B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback8B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory8B6
{
    static XorpMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 8 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory8B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 8 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory8B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 8 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback8B6 : public XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback8B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 8 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback8B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback8B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback8<void, A1, A2, A3, A4, A5, A6, A7, A8>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 8 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback8B6
    : public XorpConstMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback8B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback8B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 8 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback8B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback8B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback8B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback8B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback8B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback8B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback8B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory8B6
{
    static XorpConstMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback8B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 8 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory8B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 8 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback8<R, A1, A2, A3, A4, A5, A6, A7, A8>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory8B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 9 late args
//

/**
 * @short Base class for callbacks with 9 dispatch time args.
 */
template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
struct XorpCallback9 {
    typedef ref_ptr<XorpCallback9> RefPtr;

    XorpCallback9(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback9() {}
    virtual R dispatch(A1, A2, A3, A4, A5, A6, A7, A8, A9) = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 9 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
struct XorpFunctionCallback9B0 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
    XorpFunctionCallback9B0(const char* file, int line, F f)
	: XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _f(f)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 9 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
struct XorpFunctionCallback9B0<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> : public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
    XorpFunctionCallback9B0(const char* file, int line, F f)
	: XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _f(f)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 9 dispatch time arguments and 0 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) {
    return typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr(new XorpFunctionCallback9B0<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line, f));
}

/**
 * @short Callback object for member methods with 9 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
struct XorpMemberCallback9B0 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9) ;
    XorpMemberCallback9B0(const char* file, int line, O* o, M m)
	 : XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 9 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
struct XorpMemberCallback9B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>
: public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9) ;
    XorpMemberCallback9B0(const char* file, int line, O* o, M m)
	 : XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 9 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
struct XorpSafeMemberCallback9B0
    : public XorpMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>::M M;
    XorpSafeMemberCallback9B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback9B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 9 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
struct XorpSafeMemberCallback9B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9>
    : public XorpMemberCallback9B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback9B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>::M M;
    XorpSafeMemberCallback9B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback9B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback9B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback9B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, bool B=true>
struct XorpMemberCallbackFactory9B0
{
    static XorpMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9))
    {
	return new XorpSafeMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
struct XorpMemberCallbackFactory9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, false>
{
    static XorpMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9))
    {
	return new XorpMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 9 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9))
{
    return XorpMemberCallbackFactory9B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 9 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9))
{
    return XorpMemberCallbackFactory9B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 9 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
struct XorpConstMemberCallback9B0 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9)  const;
    XorpConstMemberCallback9B0(const char* file, int line, O* o, M m)
	 : XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 9 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
struct XorpConstMemberCallback9B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>
: public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9)  const;
    XorpConstMemberCallback9B0(const char* file, int line, O* o, M m)
	 : XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 9 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
struct XorpConstSafeMemberCallback9B0
    : public XorpConstMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>::M M;
    XorpConstSafeMemberCallback9B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback9B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 9 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
struct XorpConstSafeMemberCallback9B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9>
    : public XorpConstMemberCallback9B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback9B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>::M M;
    XorpConstSafeMemberCallback9B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback9B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback9B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback9B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, bool B=true>
struct XorpConstMemberCallbackFactory9B0
{
    static XorpConstMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const)
    {
	return new XorpConstSafeMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
struct XorpConstMemberCallbackFactory9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, false>
{
    static XorpConstMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const)
    {
	return new XorpConstMemberCallback9B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 9 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const)
{
    return XorpConstMemberCallbackFactory9B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 9 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const)
{
    return XorpConstMemberCallbackFactory9B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 9 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1>
struct XorpFunctionCallback9B1 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1);
    XorpFunctionCallback9B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 9 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1>
struct XorpFunctionCallback9B1<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1> : public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1);
    XorpFunctionCallback9B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 9 dispatch time arguments and 1 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1>
typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1), BA1 ba1) {
    return typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr(new XorpFunctionCallback9B1<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 9 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1>
struct XorpMemberCallback9B1 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1) ;
    XorpMemberCallback9B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 9 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1>
struct XorpMemberCallback9B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>
: public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1) ;
    XorpMemberCallback9B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 9 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1>
struct XorpSafeMemberCallback9B1
    : public XorpMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>::M M;
    XorpSafeMemberCallback9B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback9B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 9 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1>
struct XorpSafeMemberCallback9B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>
    : public XorpMemberCallback9B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback9B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>::M M;
    XorpSafeMemberCallback9B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback9B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback9B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback9B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, bool B=true>
struct XorpMemberCallbackFactory9B1
{
    static XorpMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1>
struct XorpMemberCallbackFactory9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, false>
{
    static XorpMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1), BA1 ba1)
    {
	return new XorpMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 9 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory9B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 9 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory9B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 9 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1>
struct XorpConstMemberCallback9B1 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1)  const;
    XorpConstMemberCallback9B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 9 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1>
struct XorpConstMemberCallback9B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>
: public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1)  const;
    XorpConstMemberCallback9B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 9 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1>
struct XorpConstSafeMemberCallback9B1
    : public XorpConstMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>::M M;
    XorpConstSafeMemberCallback9B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback9B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 9 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1>
struct XorpConstSafeMemberCallback9B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>
    : public XorpConstMemberCallback9B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback9B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>::M M;
    XorpConstSafeMemberCallback9B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback9B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback9B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback9B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory9B1
{
    static XorpConstMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1>
struct XorpConstMemberCallbackFactory9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, false>
{
    static XorpConstMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback9B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 9 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory9B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 9 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory9B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 9 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2>
struct XorpFunctionCallback9B2 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2);
    XorpFunctionCallback9B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 9 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2>
struct XorpFunctionCallback9B2<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2> : public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2);
    XorpFunctionCallback9B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 9 dispatch time arguments and 2 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2>
typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr(new XorpFunctionCallback9B2<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 9 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2>
struct XorpMemberCallback9B2 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2) ;
    XorpMemberCallback9B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 9 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2>
struct XorpMemberCallback9B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>
: public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2) ;
    XorpMemberCallback9B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 9 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2>
struct XorpSafeMemberCallback9B2
    : public XorpMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>::M M;
    XorpSafeMemberCallback9B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback9B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 9 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2>
struct XorpSafeMemberCallback9B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>
    : public XorpMemberCallback9B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback9B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>::M M;
    XorpSafeMemberCallback9B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback9B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback9B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback9B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory9B2
{
    static XorpMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2>
struct XorpMemberCallbackFactory9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, false>
{
    static XorpMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 9 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory9B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 9 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory9B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 9 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2>
struct XorpConstMemberCallback9B2 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2)  const;
    XorpConstMemberCallback9B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 9 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2>
struct XorpConstMemberCallback9B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>
: public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2)  const;
    XorpConstMemberCallback9B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 9 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2>
struct XorpConstSafeMemberCallback9B2
    : public XorpConstMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>::M M;
    XorpConstSafeMemberCallback9B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback9B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 9 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2>
struct XorpConstSafeMemberCallback9B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>
    : public XorpConstMemberCallback9B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback9B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>::M M;
    XorpConstSafeMemberCallback9B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback9B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback9B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback9B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory9B2
{
    static XorpConstMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2>
struct XorpConstMemberCallbackFactory9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, false>
{
    static XorpConstMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback9B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 9 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory9B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 9 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory9B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 9 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3>
struct XorpFunctionCallback9B3 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3);
    XorpFunctionCallback9B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 9 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3>
struct XorpFunctionCallback9B3<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3> : public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3);
    XorpFunctionCallback9B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 9 dispatch time arguments and 3 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3>
typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr(new XorpFunctionCallback9B3<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 9 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3>
struct XorpMemberCallback9B3 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3) ;
    XorpMemberCallback9B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 9 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3>
struct XorpMemberCallback9B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>
: public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3) ;
    XorpMemberCallback9B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 9 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback9B3
    : public XorpMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback9B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback9B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 9 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback9B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>
    : public XorpMemberCallback9B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback9B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback9B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback9B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback9B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback9B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory9B3
{
    static XorpMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, false>
{
    static XorpMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 9 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory9B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 9 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory9B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 9 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback9B3 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3)  const;
    XorpConstMemberCallback9B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 9 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback9B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>
: public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3)  const;
    XorpConstMemberCallback9B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 9 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback9B3
    : public XorpConstMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback9B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback9B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 9 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback9B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>
    : public XorpConstMemberCallback9B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback9B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback9B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback9B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback9B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback9B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory9B3
{
    static XorpConstMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback9B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 9 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory9B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 9 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory9B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 9 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback9B4 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4);
    XorpFunctionCallback9B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 9 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback9B4<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4> : public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4);
    XorpFunctionCallback9B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 9 dispatch time arguments and 4 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr(new XorpFunctionCallback9B4<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 9 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback9B4 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback9B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 9 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback9B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>
: public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback9B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 9 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback9B4
    : public XorpMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback9B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback9B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 9 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback9B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback9B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback9B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback9B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback9B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback9B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback9B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory9B4
{
    static XorpMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 9 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory9B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 9 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory9B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 9 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback9B4 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback9B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 9 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback9B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>
: public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback9B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 9 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback9B4
    : public XorpConstMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback9B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback9B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 9 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback9B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback9B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback9B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback9B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback9B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback9B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback9B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory9B4
{
    static XorpConstMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback9B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 9 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory9B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 9 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory9B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 9 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback9B5 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback9B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 9 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback9B5<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5> : public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback9B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 9 dispatch time arguments and 5 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr(new XorpFunctionCallback9B5<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 9 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback9B5 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback9B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 9 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback9B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback9B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 9 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback9B5
    : public XorpMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback9B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback9B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 9 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback9B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback9B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback9B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback9B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback9B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback9B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback9B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory9B5
{
    static XorpMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 9 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory9B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 9 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory9B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 9 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback9B5 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback9B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 9 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback9B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback9B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 9 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback9B5
    : public XorpConstMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback9B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback9B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 9 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback9B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback9B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback9B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback9B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback9B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback9B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback9B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory9B5
{
    static XorpConstMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback9B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 9 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory9B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 9 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory9B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 9 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback9B6 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback9B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 9 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback9B6<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback9B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 9 dispatch time arguments and 6 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr(new XorpFunctionCallback9B6<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 9 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback9B6 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback9B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 9 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback9B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback9B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 9 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback9B6
    : public XorpMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback9B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback9B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 9 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback9B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback9B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback9B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback9B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback9B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback9B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback9B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory9B6
{
    static XorpMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 9 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory9B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 9 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory9B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 9 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback9B6 : public XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback9B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 9 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback9B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback9B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback9<void, A1, A2, A3, A4, A5, A6, A7, A8, A9>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 9 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback9B6
    : public XorpConstMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback9B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback9B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 9 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback9B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback9B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback9B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback9B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback9B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback9B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback9B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory9B6
{
    static XorpConstMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback9B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 9 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory9B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 9 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory9B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 10 late args
//

/**
 * @short Base class for callbacks with 10 dispatch time args.
 */
template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
struct XorpCallback10 {
    typedef ref_ptr<XorpCallback10> RefPtr;

    XorpCallback10(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback10() {}
    virtual R dispatch(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 10 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
struct XorpFunctionCallback10B0 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
    XorpFunctionCallback10B0(const char* file, int line, F f)
	: XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _f(f)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 10 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
struct XorpFunctionCallback10B0<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> : public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
    XorpFunctionCallback10B0(const char* file, int line, F f)
	: XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _f(f)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 10 dispatch time arguments and 0 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) {
    return typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr(new XorpFunctionCallback10B0<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line, f));
}

/**
 * @short Callback object for member methods with 10 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
struct XorpMemberCallback10B0 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ;
    XorpMemberCallback10B0(const char* file, int line, O* o, M m)
	 : XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 10 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
struct XorpMemberCallback10B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>
: public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ;
    XorpMemberCallback10B0(const char* file, int line, O* o, M m)
	 : XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 10 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
struct XorpSafeMemberCallback10B0
    : public XorpMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::M M;
    XorpSafeMemberCallback10B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback10B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 10 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
struct XorpSafeMemberCallback10B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>
    : public XorpMemberCallback10B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback10B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::M M;
    XorpSafeMemberCallback10B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback10B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback10B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback10B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, bool B=true>
struct XorpMemberCallbackFactory10B0
{
    static XorpMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))
    {
	return new XorpSafeMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
struct XorpMemberCallbackFactory10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, false>
{
    static XorpMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))
    {
	return new XorpMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 10 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))
{
    return XorpMemberCallbackFactory10B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 10 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))
{
    return XorpMemberCallbackFactory10B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 10 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
struct XorpConstMemberCallback10B0 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)  const;
    XorpConstMemberCallback10B0(const char* file, int line, O* o, M m)
	 : XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 10 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
struct XorpConstMemberCallback10B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>
: public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)  const;
    XorpConstMemberCallback10B0(const char* file, int line, O* o, M m)
	 : XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 10 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
struct XorpConstSafeMemberCallback10B0
    : public XorpConstMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::M M;
    XorpConstSafeMemberCallback10B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback10B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 10 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
struct XorpConstSafeMemberCallback10B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>
    : public XorpConstMemberCallback10B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback10B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::M M;
    XorpConstSafeMemberCallback10B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback10B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback10B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback10B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, bool B=true>
struct XorpConstMemberCallbackFactory10B0
{
    static XorpConstMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const)
    {
	return new XorpConstSafeMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
struct XorpConstMemberCallbackFactory10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, false>
{
    static XorpConstMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const)
    {
	return new XorpConstMemberCallback10B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 10 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const)
{
    return XorpConstMemberCallbackFactory10B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 10 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const)
{
    return XorpConstMemberCallbackFactory10B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 10 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1>
struct XorpFunctionCallback10B1 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1);
    XorpFunctionCallback10B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 10 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1>
struct XorpFunctionCallback10B1<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1> : public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1);
    XorpFunctionCallback10B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 10 dispatch time arguments and 1 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1>
typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1), BA1 ba1) {
    return typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr(new XorpFunctionCallback10B1<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 10 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1>
struct XorpMemberCallback10B1 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1) ;
    XorpMemberCallback10B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 10 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1>
struct XorpMemberCallback10B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>
: public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1) ;
    XorpMemberCallback10B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 10 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1>
struct XorpSafeMemberCallback10B1
    : public XorpMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>::M M;
    XorpSafeMemberCallback10B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback10B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 10 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1>
struct XorpSafeMemberCallback10B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>
    : public XorpMemberCallback10B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback10B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>::M M;
    XorpSafeMemberCallback10B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback10B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback10B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback10B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, bool B=true>
struct XorpMemberCallbackFactory10B1
{
    static XorpMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1>
struct XorpMemberCallbackFactory10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, false>
{
    static XorpMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1), BA1 ba1)
    {
	return new XorpMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 10 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory10B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 10 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory10B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 10 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1>
struct XorpConstMemberCallback10B1 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1)  const;
    XorpConstMemberCallback10B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 10 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1>
struct XorpConstMemberCallback10B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>
: public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1)  const;
    XorpConstMemberCallback10B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 10 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1>
struct XorpConstSafeMemberCallback10B1
    : public XorpConstMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>::M M;
    XorpConstSafeMemberCallback10B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback10B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 10 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1>
struct XorpConstSafeMemberCallback10B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>
    : public XorpConstMemberCallback10B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback10B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>::M M;
    XorpConstSafeMemberCallback10B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback10B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback10B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback10B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory10B1
{
    static XorpConstMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1>
struct XorpConstMemberCallbackFactory10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, false>
{
    static XorpConstMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback10B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 10 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory10B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 10 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory10B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 10 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2>
struct XorpFunctionCallback10B2 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2);
    XorpFunctionCallback10B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 10 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2>
struct XorpFunctionCallback10B2<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2> : public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2);
    XorpFunctionCallback10B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 10 dispatch time arguments and 2 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2>
typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr(new XorpFunctionCallback10B2<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 10 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2>
struct XorpMemberCallback10B2 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2) ;
    XorpMemberCallback10B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 10 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2>
struct XorpMemberCallback10B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>
: public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2) ;
    XorpMemberCallback10B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 10 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2>
struct XorpSafeMemberCallback10B2
    : public XorpMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>::M M;
    XorpSafeMemberCallback10B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback10B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 10 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2>
struct XorpSafeMemberCallback10B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>
    : public XorpMemberCallback10B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback10B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>::M M;
    XorpSafeMemberCallback10B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback10B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback10B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback10B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory10B2
{
    static XorpMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2>
struct XorpMemberCallbackFactory10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, false>
{
    static XorpMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 10 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory10B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 10 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory10B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 10 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2>
struct XorpConstMemberCallback10B2 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2)  const;
    XorpConstMemberCallback10B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 10 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2>
struct XorpConstMemberCallback10B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>
: public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2)  const;
    XorpConstMemberCallback10B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 10 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2>
struct XorpConstSafeMemberCallback10B2
    : public XorpConstMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>::M M;
    XorpConstSafeMemberCallback10B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback10B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 10 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2>
struct XorpConstSafeMemberCallback10B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>
    : public XorpConstMemberCallback10B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback10B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>::M M;
    XorpConstSafeMemberCallback10B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback10B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback10B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback10B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory10B2
{
    static XorpConstMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2>
struct XorpConstMemberCallbackFactory10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, false>
{
    static XorpConstMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback10B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 10 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory10B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 10 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory10B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 10 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3>
struct XorpFunctionCallback10B3 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3);
    XorpFunctionCallback10B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 10 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3>
struct XorpFunctionCallback10B3<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3> : public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3);
    XorpFunctionCallback10B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 10 dispatch time arguments and 3 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3>
typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr(new XorpFunctionCallback10B3<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 10 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3>
struct XorpMemberCallback10B3 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3) ;
    XorpMemberCallback10B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 10 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3>
struct XorpMemberCallback10B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>
: public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3) ;
    XorpMemberCallback10B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 10 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback10B3
    : public XorpMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback10B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback10B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 10 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback10B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>
    : public XorpMemberCallback10B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback10B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback10B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback10B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback10B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback10B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory10B3
{
    static XorpMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, false>
{
    static XorpMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 10 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory10B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 10 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory10B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 10 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback10B3 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3)  const;
    XorpConstMemberCallback10B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 10 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback10B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>
: public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3)  const;
    XorpConstMemberCallback10B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 10 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback10B3
    : public XorpConstMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback10B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback10B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 10 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback10B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>
    : public XorpConstMemberCallback10B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback10B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback10B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback10B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback10B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback10B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory10B3
{
    static XorpConstMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback10B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 10 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory10B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 10 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory10B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 10 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback10B4 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4);
    XorpFunctionCallback10B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 10 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback10B4<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4> : public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4);
    XorpFunctionCallback10B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 10 dispatch time arguments and 4 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr(new XorpFunctionCallback10B4<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 10 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback10B4 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback10B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 10 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback10B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>
: public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback10B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 10 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback10B4
    : public XorpMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback10B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback10B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 10 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback10B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback10B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback10B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback10B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback10B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback10B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback10B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory10B4
{
    static XorpMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 10 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory10B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 10 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory10B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 10 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback10B4 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback10B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 10 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback10B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>
: public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback10B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 10 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback10B4
    : public XorpConstMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback10B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback10B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 10 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback10B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback10B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback10B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback10B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback10B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback10B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback10B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory10B4
{
    static XorpConstMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback10B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 10 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory10B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 10 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory10B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 10 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback10B5 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback10B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 10 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback10B5<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5> : public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback10B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 10 dispatch time arguments and 5 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr(new XorpFunctionCallback10B5<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 10 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback10B5 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback10B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 10 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback10B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback10B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 10 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback10B5
    : public XorpMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback10B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback10B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 10 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback10B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback10B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback10B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback10B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback10B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback10B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback10B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory10B5
{
    static XorpMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 10 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory10B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 10 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory10B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 10 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback10B5 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback10B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 10 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback10B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback10B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 10 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback10B5
    : public XorpConstMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback10B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback10B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 10 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback10B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback10B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback10B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback10B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback10B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback10B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback10B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory10B5
{
    static XorpConstMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback10B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 10 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory10B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 10 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory10B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 10 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback10B6 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback10B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 10 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback10B6<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback10B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 10 dispatch time arguments and 6 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr(new XorpFunctionCallback10B6<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 10 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback10B6 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback10B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 10 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback10B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback10B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 10 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback10B6
    : public XorpMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback10B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback10B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 10 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback10B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback10B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback10B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback10B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback10B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback10B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback10B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory10B6
{
    static XorpMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 10 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory10B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 10 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory10B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 10 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback10B6 : public XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback10B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 10 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback10B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback10B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback10<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 10 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback10B6
    : public XorpConstMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback10B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback10B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 10 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback10B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback10B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback10B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback10B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback10B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback10B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback10B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory10B6
{
    static XorpConstMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback10B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 10 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory10B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 10 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory10B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 11 late args
//

/**
 * @short Base class for callbacks with 11 dispatch time args.
 */
template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
struct XorpCallback11 {
    typedef ref_ptr<XorpCallback11> RefPtr;

    XorpCallback11(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback11() {}
    virtual R dispatch(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 11 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
struct XorpFunctionCallback11B0 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
    XorpFunctionCallback11B0(const char* file, int line, F f)
	: XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _f(f)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 11 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
struct XorpFunctionCallback11B0<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> : public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
    XorpFunctionCallback11B0(const char* file, int line, F f)
	: XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _f(f)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 11 dispatch time arguments and 0 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)) {
    return typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr(new XorpFunctionCallback11B0<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line, f));
}

/**
 * @short Callback object for member methods with 11 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
struct XorpMemberCallback11B0 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ;
    XorpMemberCallback11B0(const char* file, int line, O* o, M m)
	 : XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 11 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
struct XorpMemberCallback11B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>
: public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ;
    XorpMemberCallback11B0(const char* file, int line, O* o, M m)
	 : XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 11 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
struct XorpSafeMemberCallback11B0
    : public XorpMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::M M;
    XorpSafeMemberCallback11B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback11B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 11 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
struct XorpSafeMemberCallback11B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>
    : public XorpMemberCallback11B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback11B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::M M;
    XorpSafeMemberCallback11B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback11B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback11B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback11B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, bool B=true>
struct XorpMemberCallbackFactory11B0
{
    static XorpMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))
    {
	return new XorpSafeMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
struct XorpMemberCallbackFactory11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, false>
{
    static XorpMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))
    {
	return new XorpMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 11 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))
{
    return XorpMemberCallbackFactory11B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 11 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))
{
    return XorpMemberCallbackFactory11B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 11 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
struct XorpConstMemberCallback11B0 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)  const;
    XorpConstMemberCallback11B0(const char* file, int line, O* o, M m)
	 : XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 11 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
struct XorpConstMemberCallback11B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>
: public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)  const;
    XorpConstMemberCallback11B0(const char* file, int line, O* o, M m)
	 : XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 11 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
struct XorpConstSafeMemberCallback11B0
    : public XorpConstMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::M M;
    XorpConstSafeMemberCallback11B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback11B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 11 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
struct XorpConstSafeMemberCallback11B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>
    : public XorpConstMemberCallback11B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback11B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::M M;
    XorpConstSafeMemberCallback11B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback11B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback11B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback11B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, bool B=true>
struct XorpConstMemberCallbackFactory11B0
{
    static XorpConstMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const)
    {
	return new XorpConstSafeMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
struct XorpConstMemberCallbackFactory11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, false>
{
    static XorpConstMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const)
    {
	return new XorpConstMemberCallback11B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 11 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const)
{
    return XorpConstMemberCallbackFactory11B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 11 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const)
{
    return XorpConstMemberCallbackFactory11B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 11 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1>
struct XorpFunctionCallback11B1 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1);
    XorpFunctionCallback11B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 11 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1>
struct XorpFunctionCallback11B1<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1> : public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1);
    XorpFunctionCallback11B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 11 dispatch time arguments and 1 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1>
typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1), BA1 ba1) {
    return typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr(new XorpFunctionCallback11B1<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 11 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1>
struct XorpMemberCallback11B1 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1) ;
    XorpMemberCallback11B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 11 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1>
struct XorpMemberCallback11B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>
: public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1) ;
    XorpMemberCallback11B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 11 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1>
struct XorpSafeMemberCallback11B1
    : public XorpMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>::M M;
    XorpSafeMemberCallback11B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback11B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 11 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1>
struct XorpSafeMemberCallback11B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>
    : public XorpMemberCallback11B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback11B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>::M M;
    XorpSafeMemberCallback11B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback11B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback11B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback11B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, bool B=true>
struct XorpMemberCallbackFactory11B1
{
    static XorpMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1>
struct XorpMemberCallbackFactory11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, false>
{
    static XorpMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1), BA1 ba1)
    {
	return new XorpMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 11 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory11B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 11 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory11B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 11 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1>
struct XorpConstMemberCallback11B1 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1)  const;
    XorpConstMemberCallback11B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 11 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1>
struct XorpConstMemberCallback11B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>
: public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1)  const;
    XorpConstMemberCallback11B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 11 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1>
struct XorpConstSafeMemberCallback11B1
    : public XorpConstMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>::M M;
    XorpConstSafeMemberCallback11B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback11B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 11 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1>
struct XorpConstSafeMemberCallback11B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>
    : public XorpConstMemberCallback11B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback11B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>::M M;
    XorpConstSafeMemberCallback11B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback11B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback11B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback11B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory11B1
{
    static XorpConstMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1>
struct XorpConstMemberCallbackFactory11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, false>
{
    static XorpConstMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback11B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 11 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory11B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 11 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory11B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 11 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2>
struct XorpFunctionCallback11B2 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2);
    XorpFunctionCallback11B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 11 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2>
struct XorpFunctionCallback11B2<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2> : public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2);
    XorpFunctionCallback11B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 11 dispatch time arguments and 2 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2>
typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr(new XorpFunctionCallback11B2<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 11 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2>
struct XorpMemberCallback11B2 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2) ;
    XorpMemberCallback11B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 11 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2>
struct XorpMemberCallback11B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>
: public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2) ;
    XorpMemberCallback11B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 11 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2>
struct XorpSafeMemberCallback11B2
    : public XorpMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>::M M;
    XorpSafeMemberCallback11B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback11B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 11 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2>
struct XorpSafeMemberCallback11B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>
    : public XorpMemberCallback11B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback11B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>::M M;
    XorpSafeMemberCallback11B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback11B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback11B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback11B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory11B2
{
    static XorpMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2>
struct XorpMemberCallbackFactory11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, false>
{
    static XorpMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 11 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory11B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 11 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory11B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 11 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2>
struct XorpConstMemberCallback11B2 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2)  const;
    XorpConstMemberCallback11B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 11 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2>
struct XorpConstMemberCallback11B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>
: public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2)  const;
    XorpConstMemberCallback11B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 11 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2>
struct XorpConstSafeMemberCallback11B2
    : public XorpConstMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>::M M;
    XorpConstSafeMemberCallback11B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback11B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 11 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2>
struct XorpConstSafeMemberCallback11B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>
    : public XorpConstMemberCallback11B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback11B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>::M M;
    XorpConstSafeMemberCallback11B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback11B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback11B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback11B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory11B2
{
    static XorpConstMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2>
struct XorpConstMemberCallbackFactory11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, false>
{
    static XorpConstMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback11B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 11 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory11B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 11 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory11B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 11 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3>
struct XorpFunctionCallback11B3 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3);
    XorpFunctionCallback11B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 11 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3>
struct XorpFunctionCallback11B3<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3> : public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3);
    XorpFunctionCallback11B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 11 dispatch time arguments and 3 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3>
typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr(new XorpFunctionCallback11B3<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 11 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3>
struct XorpMemberCallback11B3 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3) ;
    XorpMemberCallback11B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 11 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3>
struct XorpMemberCallback11B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>
: public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3) ;
    XorpMemberCallback11B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 11 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback11B3
    : public XorpMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback11B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback11B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 11 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback11B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>
    : public XorpMemberCallback11B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback11B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback11B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback11B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback11B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback11B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory11B3
{
    static XorpMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, false>
{
    static XorpMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 11 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory11B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 11 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory11B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 11 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback11B3 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3)  const;
    XorpConstMemberCallback11B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 11 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback11B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>
: public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3)  const;
    XorpConstMemberCallback11B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 11 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback11B3
    : public XorpConstMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback11B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback11B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 11 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback11B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>
    : public XorpConstMemberCallback11B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback11B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback11B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback11B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback11B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback11B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory11B3
{
    static XorpConstMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback11B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 11 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory11B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 11 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory11B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 11 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback11B4 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4);
    XorpFunctionCallback11B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 11 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback11B4<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4> : public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4);
    XorpFunctionCallback11B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 11 dispatch time arguments and 4 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr(new XorpFunctionCallback11B4<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 11 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback11B4 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback11B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 11 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback11B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>
: public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback11B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 11 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback11B4
    : public XorpMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback11B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback11B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 11 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback11B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback11B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback11B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback11B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback11B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback11B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback11B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory11B4
{
    static XorpMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 11 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory11B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 11 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory11B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 11 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback11B4 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback11B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 11 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback11B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>
: public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback11B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 11 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback11B4
    : public XorpConstMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback11B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback11B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 11 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback11B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback11B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback11B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback11B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback11B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback11B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback11B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory11B4
{
    static XorpConstMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback11B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 11 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory11B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 11 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory11B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 11 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback11B5 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback11B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 11 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback11B5<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5> : public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback11B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 11 dispatch time arguments and 5 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr(new XorpFunctionCallback11B5<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 11 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback11B5 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback11B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 11 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback11B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback11B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 11 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback11B5
    : public XorpMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback11B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback11B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 11 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback11B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback11B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback11B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback11B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback11B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback11B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback11B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory11B5
{
    static XorpMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 11 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory11B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 11 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory11B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 11 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback11B5 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback11B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 11 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback11B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback11B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 11 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback11B5
    : public XorpConstMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback11B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback11B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 11 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback11B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback11B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback11B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback11B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback11B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback11B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback11B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory11B5
{
    static XorpConstMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback11B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 11 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory11B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 11 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory11B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 11 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback11B6 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback11B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 11 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback11B6<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback11B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 11 dispatch time arguments and 6 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr(new XorpFunctionCallback11B6<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 11 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback11B6 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback11B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 11 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback11B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback11B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 11 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback11B6
    : public XorpMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback11B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback11B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 11 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback11B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback11B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback11B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback11B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback11B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback11B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback11B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory11B6
{
    static XorpMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 11 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory11B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 11 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory11B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 11 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback11B6 : public XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback11B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 11 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback11B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback11B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback11<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 11 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback11B6
    : public XorpConstMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback11B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback11B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 11 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback11B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback11B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback11B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback11B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback11B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback11B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback11B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory11B6
{
    static XorpConstMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback11B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 11 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory11B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 11 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback11<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory11B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 12 late args
//

/**
 * @short Base class for callbacks with 12 dispatch time args.
 */
template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
struct XorpCallback12 {
    typedef ref_ptr<XorpCallback12> RefPtr;

    XorpCallback12(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback12() {}
    virtual R dispatch(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 12 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
struct XorpFunctionCallback12B0 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
    XorpFunctionCallback12B0(const char* file, int line, F f)
	: XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _f(f)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 12 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
struct XorpFunctionCallback12B0<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> : public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
    XorpFunctionCallback12B0(const char* file, int line, F f)
	: XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _f(f)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 12 dispatch time arguments and 0 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)) {
    return typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr(new XorpFunctionCallback12B0<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line, f));
}

/**
 * @short Callback object for member methods with 12 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
struct XorpMemberCallback12B0 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ;
    XorpMemberCallback12B0(const char* file, int line, O* o, M m)
	 : XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 12 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
struct XorpMemberCallback12B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>
: public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ;
    XorpMemberCallback12B0(const char* file, int line, O* o, M m)
	 : XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 12 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
struct XorpSafeMemberCallback12B0
    : public XorpMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::M M;
    XorpSafeMemberCallback12B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback12B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 12 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
struct XorpSafeMemberCallback12B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>
    : public XorpMemberCallback12B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback12B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::M M;
    XorpSafeMemberCallback12B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback12B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback12B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback12B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, bool B=true>
struct XorpMemberCallbackFactory12B0
{
    static XorpMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))
    {
	return new XorpSafeMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
struct XorpMemberCallbackFactory12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, false>
{
    static XorpMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))
    {
	return new XorpMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 12 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))
{
    return XorpMemberCallbackFactory12B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 12 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))
{
    return XorpMemberCallbackFactory12B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 12 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
struct XorpConstMemberCallback12B0 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)  const;
    XorpConstMemberCallback12B0(const char* file, int line, O* o, M m)
	 : XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 12 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
struct XorpConstMemberCallback12B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>
: public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)  const;
    XorpConstMemberCallback12B0(const char* file, int line, O* o, M m)
	 : XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 12 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
struct XorpConstSafeMemberCallback12B0
    : public XorpConstMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::M M;
    XorpConstSafeMemberCallback12B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback12B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 12 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
struct XorpConstSafeMemberCallback12B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>
    : public XorpConstMemberCallback12B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback12B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::M M;
    XorpConstSafeMemberCallback12B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback12B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback12B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback12B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, bool B=true>
struct XorpConstMemberCallbackFactory12B0
{
    static XorpConstMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const)
    {
	return new XorpConstSafeMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12>
struct XorpConstMemberCallbackFactory12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, false>
{
    static XorpConstMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const)
    {
	return new XorpConstMemberCallback12B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 12 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const)
{
    return XorpConstMemberCallbackFactory12B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 12 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const)
{
    return XorpConstMemberCallbackFactory12B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 12 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1>
struct XorpFunctionCallback12B1 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1);
    XorpFunctionCallback12B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 12 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1>
struct XorpFunctionCallback12B1<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1> : public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1);
    XorpFunctionCallback12B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 12 dispatch time arguments and 1 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1>
typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1), BA1 ba1) {
    return typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr(new XorpFunctionCallback12B1<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 12 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1>
struct XorpMemberCallback12B1 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1) ;
    XorpMemberCallback12B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 12 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1>
struct XorpMemberCallback12B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>
: public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1) ;
    XorpMemberCallback12B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 12 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1>
struct XorpSafeMemberCallback12B1
    : public XorpMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>::M M;
    XorpSafeMemberCallback12B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback12B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 12 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1>
struct XorpSafeMemberCallback12B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>
    : public XorpMemberCallback12B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback12B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>::M M;
    XorpSafeMemberCallback12B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback12B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback12B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback12B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, bool B=true>
struct XorpMemberCallbackFactory12B1
{
    static XorpMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1>
struct XorpMemberCallbackFactory12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, false>
{
    static XorpMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1), BA1 ba1)
    {
	return new XorpMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 12 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory12B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 12 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory12B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 12 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1>
struct XorpConstMemberCallback12B1 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1)  const;
    XorpConstMemberCallback12B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 12 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1>
struct XorpConstMemberCallback12B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>
: public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1)  const;
    XorpConstMemberCallback12B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 12 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1>
struct XorpConstSafeMemberCallback12B1
    : public XorpConstMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>::M M;
    XorpConstSafeMemberCallback12B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback12B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 12 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1>
struct XorpConstSafeMemberCallback12B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>
    : public XorpConstMemberCallback12B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback12B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>::M M;
    XorpConstSafeMemberCallback12B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback12B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback12B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback12B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory12B1
{
    static XorpConstMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1>
struct XorpConstMemberCallbackFactory12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, false>
{
    static XorpConstMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback12B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 12 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory12B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 12 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory12B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 12 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2>
struct XorpFunctionCallback12B2 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2);
    XorpFunctionCallback12B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 12 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2>
struct XorpFunctionCallback12B2<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2> : public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2);
    XorpFunctionCallback12B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 12 dispatch time arguments and 2 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2>
typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr(new XorpFunctionCallback12B2<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 12 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2>
struct XorpMemberCallback12B2 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2) ;
    XorpMemberCallback12B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 12 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2>
struct XorpMemberCallback12B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>
: public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2) ;
    XorpMemberCallback12B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 12 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2>
struct XorpSafeMemberCallback12B2
    : public XorpMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>::M M;
    XorpSafeMemberCallback12B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback12B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 12 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2>
struct XorpSafeMemberCallback12B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>
    : public XorpMemberCallback12B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback12B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>::M M;
    XorpSafeMemberCallback12B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback12B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback12B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback12B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory12B2
{
    static XorpMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2>
struct XorpMemberCallbackFactory12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, false>
{
    static XorpMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 12 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory12B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 12 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory12B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 12 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2>
struct XorpConstMemberCallback12B2 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2)  const;
    XorpConstMemberCallback12B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 12 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2>
struct XorpConstMemberCallback12B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>
: public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2)  const;
    XorpConstMemberCallback12B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 12 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2>
struct XorpConstSafeMemberCallback12B2
    : public XorpConstMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>::M M;
    XorpConstSafeMemberCallback12B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback12B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 12 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2>
struct XorpConstSafeMemberCallback12B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>
    : public XorpConstMemberCallback12B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback12B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>::M M;
    XorpConstSafeMemberCallback12B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback12B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback12B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback12B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory12B2
{
    static XorpConstMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2>
struct XorpConstMemberCallbackFactory12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, false>
{
    static XorpConstMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback12B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 12 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory12B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 12 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory12B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 12 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3>
struct XorpFunctionCallback12B3 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3);
    XorpFunctionCallback12B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 12 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3>
struct XorpFunctionCallback12B3<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3> : public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3);
    XorpFunctionCallback12B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 12 dispatch time arguments and 3 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3>
typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr(new XorpFunctionCallback12B3<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 12 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3>
struct XorpMemberCallback12B3 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3) ;
    XorpMemberCallback12B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 12 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3>
struct XorpMemberCallback12B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>
: public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3) ;
    XorpMemberCallback12B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 12 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback12B3
    : public XorpMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback12B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback12B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 12 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback12B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>
    : public XorpMemberCallback12B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback12B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback12B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback12B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback12B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback12B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory12B3
{
    static XorpMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, false>
{
    static XorpMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 12 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory12B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 12 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory12B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 12 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback12B3 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3)  const;
    XorpConstMemberCallback12B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 12 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback12B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>
: public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3)  const;
    XorpConstMemberCallback12B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 12 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback12B3
    : public XorpConstMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback12B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback12B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 12 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback12B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>
    : public XorpConstMemberCallback12B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback12B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback12B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback12B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback12B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback12B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory12B3
{
    static XorpConstMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback12B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 12 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory12B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 12 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory12B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 12 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback12B4 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4);
    XorpFunctionCallback12B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 12 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback12B4<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4> : public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4);
    XorpFunctionCallback12B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 12 dispatch time arguments and 4 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr(new XorpFunctionCallback12B4<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 12 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback12B4 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback12B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 12 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback12B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>
: public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback12B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 12 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback12B4
    : public XorpMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback12B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback12B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 12 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback12B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback12B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback12B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback12B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback12B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback12B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback12B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory12B4
{
    static XorpMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 12 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory12B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 12 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory12B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 12 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback12B4 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback12B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 12 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback12B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>
: public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback12B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 12 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback12B4
    : public XorpConstMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback12B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback12B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 12 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback12B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback12B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback12B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback12B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback12B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback12B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback12B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory12B4
{
    static XorpConstMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback12B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 12 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory12B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 12 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory12B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 12 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback12B5 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback12B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 12 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback12B5<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5> : public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback12B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 12 dispatch time arguments and 5 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr(new XorpFunctionCallback12B5<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 12 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback12B5 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback12B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 12 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback12B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback12B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 12 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback12B5
    : public XorpMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback12B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback12B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 12 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback12B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback12B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback12B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback12B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback12B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback12B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback12B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory12B5
{
    static XorpMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 12 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory12B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 12 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory12B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 12 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback12B5 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback12B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 12 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback12B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback12B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 12 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback12B5
    : public XorpConstMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback12B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback12B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 12 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback12B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback12B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback12B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback12B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback12B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback12B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback12B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory12B5
{
    static XorpConstMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback12B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 12 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory12B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 12 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory12B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 12 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback12B6 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback12B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 12 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback12B6<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback12B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 12 dispatch time arguments and 6 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr(new XorpFunctionCallback12B6<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 12 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback12B6 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback12B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 12 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback12B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback12B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 12 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback12B6
    : public XorpMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback12B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback12B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 12 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback12B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback12B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback12B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback12B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback12B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback12B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback12B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory12B6
{
    static XorpMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 12 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory12B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 12 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory12B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 12 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback12B6 : public XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback12B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 12 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback12B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback12B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback12<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 12 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback12B6
    : public XorpConstMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback12B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback12B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 12 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback12B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback12B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback12B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback12B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback12B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback12B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback12B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory12B6
{
    static XorpConstMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback12B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 12 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory12B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 12 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback12<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory12B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 13 late args
//

/**
 * @short Base class for callbacks with 13 dispatch time args.
 */
template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
struct XorpCallback13 {
    typedef ref_ptr<XorpCallback13> RefPtr;

    XorpCallback13(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback13() {}
    virtual R dispatch(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 13 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
struct XorpFunctionCallback13B0 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
    XorpFunctionCallback13B0(const char* file, int line, F f)
	: XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _f(f)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 13 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
struct XorpFunctionCallback13B0<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> : public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
    XorpFunctionCallback13B0(const char* file, int line, F f)
	: XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _f(f)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 13 dispatch time arguments and 0 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)) {
    return typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr(new XorpFunctionCallback13B0<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line, f));
}

/**
 * @short Callback object for member methods with 13 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
struct XorpMemberCallback13B0 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ;
    XorpMemberCallback13B0(const char* file, int line, O* o, M m)
	 : XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 13 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
struct XorpMemberCallback13B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>
: public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ;
    XorpMemberCallback13B0(const char* file, int line, O* o, M m)
	 : XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 13 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
struct XorpSafeMemberCallback13B0
    : public XorpMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::M M;
    XorpSafeMemberCallback13B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback13B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 13 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
struct XorpSafeMemberCallback13B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>
    : public XorpMemberCallback13B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback13B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::M M;
    XorpSafeMemberCallback13B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback13B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback13B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback13B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, bool B=true>
struct XorpMemberCallbackFactory13B0
{
    static XorpMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))
    {
	return new XorpSafeMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
struct XorpMemberCallbackFactory13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, false>
{
    static XorpMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))
    {
	return new XorpMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 13 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))
{
    return XorpMemberCallbackFactory13B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 13 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))
{
    return XorpMemberCallbackFactory13B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 13 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
struct XorpConstMemberCallback13B0 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)  const;
    XorpConstMemberCallback13B0(const char* file, int line, O* o, M m)
	 : XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 13 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
struct XorpConstMemberCallback13B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>
: public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)  const;
    XorpConstMemberCallback13B0(const char* file, int line, O* o, M m)
	 : XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 13 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
struct XorpConstSafeMemberCallback13B0
    : public XorpConstMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::M M;
    XorpConstSafeMemberCallback13B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback13B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 13 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
struct XorpConstSafeMemberCallback13B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>
    : public XorpConstMemberCallback13B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback13B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::M M;
    XorpConstSafeMemberCallback13B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback13B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback13B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback13B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, bool B=true>
struct XorpConstMemberCallbackFactory13B0
{
    static XorpConstMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const)
    {
	return new XorpConstSafeMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13>
struct XorpConstMemberCallbackFactory13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, false>
{
    static XorpConstMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const)
    {
	return new XorpConstMemberCallback13B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 13 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const)
{
    return XorpConstMemberCallbackFactory13B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 13 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const)
{
    return XorpConstMemberCallbackFactory13B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 13 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1>
struct XorpFunctionCallback13B1 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1);
    XorpFunctionCallback13B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 13 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1>
struct XorpFunctionCallback13B1<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1> : public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1);
    XorpFunctionCallback13B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 13 dispatch time arguments and 1 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1>
typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1), BA1 ba1) {
    return typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr(new XorpFunctionCallback13B1<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 13 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1>
struct XorpMemberCallback13B1 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1) ;
    XorpMemberCallback13B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 13 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1>
struct XorpMemberCallback13B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>
: public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1) ;
    XorpMemberCallback13B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 13 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1>
struct XorpSafeMemberCallback13B1
    : public XorpMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>::M M;
    XorpSafeMemberCallback13B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback13B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 13 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1>
struct XorpSafeMemberCallback13B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>
    : public XorpMemberCallback13B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback13B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>::M M;
    XorpSafeMemberCallback13B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback13B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback13B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback13B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, bool B=true>
struct XorpMemberCallbackFactory13B1
{
    static XorpMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1>
struct XorpMemberCallbackFactory13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, false>
{
    static XorpMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1), BA1 ba1)
    {
	return new XorpMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 13 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory13B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 13 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory13B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 13 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1>
struct XorpConstMemberCallback13B1 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1)  const;
    XorpConstMemberCallback13B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 13 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1>
struct XorpConstMemberCallback13B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>
: public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1)  const;
    XorpConstMemberCallback13B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 13 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1>
struct XorpConstSafeMemberCallback13B1
    : public XorpConstMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>::M M;
    XorpConstSafeMemberCallback13B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback13B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 13 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1>
struct XorpConstSafeMemberCallback13B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>
    : public XorpConstMemberCallback13B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback13B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>::M M;
    XorpConstSafeMemberCallback13B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback13B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback13B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback13B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory13B1
{
    static XorpConstMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1>
struct XorpConstMemberCallbackFactory13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, false>
{
    static XorpConstMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback13B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 13 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory13B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 13 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory13B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 13 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2>
struct XorpFunctionCallback13B2 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2);
    XorpFunctionCallback13B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 13 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2>
struct XorpFunctionCallback13B2<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2> : public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2);
    XorpFunctionCallback13B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 13 dispatch time arguments and 2 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2>
typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr(new XorpFunctionCallback13B2<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 13 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2>
struct XorpMemberCallback13B2 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2) ;
    XorpMemberCallback13B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 13 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2>
struct XorpMemberCallback13B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>
: public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2) ;
    XorpMemberCallback13B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 13 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2>
struct XorpSafeMemberCallback13B2
    : public XorpMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>::M M;
    XorpSafeMemberCallback13B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback13B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 13 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2>
struct XorpSafeMemberCallback13B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>
    : public XorpMemberCallback13B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback13B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>::M M;
    XorpSafeMemberCallback13B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback13B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback13B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback13B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory13B2
{
    static XorpMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2>
struct XorpMemberCallbackFactory13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, false>
{
    static XorpMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 13 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory13B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 13 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory13B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 13 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2>
struct XorpConstMemberCallback13B2 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2)  const;
    XorpConstMemberCallback13B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 13 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2>
struct XorpConstMemberCallback13B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>
: public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2)  const;
    XorpConstMemberCallback13B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 13 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2>
struct XorpConstSafeMemberCallback13B2
    : public XorpConstMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>::M M;
    XorpConstSafeMemberCallback13B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback13B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 13 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2>
struct XorpConstSafeMemberCallback13B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>
    : public XorpConstMemberCallback13B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback13B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>::M M;
    XorpConstSafeMemberCallback13B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback13B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback13B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback13B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory13B2
{
    static XorpConstMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2>
struct XorpConstMemberCallbackFactory13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, false>
{
    static XorpConstMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback13B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 13 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory13B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 13 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory13B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 13 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3>
struct XorpFunctionCallback13B3 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3);
    XorpFunctionCallback13B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 13 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3>
struct XorpFunctionCallback13B3<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3> : public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3);
    XorpFunctionCallback13B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 13 dispatch time arguments and 3 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3>
typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr(new XorpFunctionCallback13B3<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 13 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3>
struct XorpMemberCallback13B3 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3) ;
    XorpMemberCallback13B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 13 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3>
struct XorpMemberCallback13B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>
: public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3) ;
    XorpMemberCallback13B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 13 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback13B3
    : public XorpMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback13B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback13B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 13 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback13B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>
    : public XorpMemberCallback13B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback13B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback13B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback13B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback13B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback13B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory13B3
{
    static XorpMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, false>
{
    static XorpMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 13 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory13B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 13 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory13B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 13 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback13B3 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3)  const;
    XorpConstMemberCallback13B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 13 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback13B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>
: public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3)  const;
    XorpConstMemberCallback13B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 13 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback13B3
    : public XorpConstMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback13B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback13B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 13 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback13B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>
    : public XorpConstMemberCallback13B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback13B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback13B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback13B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback13B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback13B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory13B3
{
    static XorpConstMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback13B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 13 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory13B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 13 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory13B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 13 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback13B4 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4);
    XorpFunctionCallback13B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 13 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback13B4<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4> : public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4);
    XorpFunctionCallback13B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 13 dispatch time arguments and 4 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr(new XorpFunctionCallback13B4<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 13 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback13B4 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback13B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 13 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback13B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>
: public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback13B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 13 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback13B4
    : public XorpMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback13B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback13B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 13 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback13B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback13B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback13B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback13B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback13B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback13B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback13B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory13B4
{
    static XorpMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 13 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory13B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 13 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory13B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 13 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback13B4 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback13B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 13 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback13B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>
: public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback13B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 13 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback13B4
    : public XorpConstMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback13B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback13B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 13 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback13B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback13B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback13B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback13B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback13B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback13B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback13B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory13B4
{
    static XorpConstMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback13B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 13 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory13B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 13 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory13B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 13 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback13B5 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback13B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 13 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback13B5<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5> : public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback13B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 13 dispatch time arguments and 5 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr(new XorpFunctionCallback13B5<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 13 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback13B5 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback13B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 13 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback13B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback13B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 13 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback13B5
    : public XorpMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback13B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback13B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 13 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback13B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback13B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback13B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback13B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback13B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback13B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback13B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory13B5
{
    static XorpMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 13 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory13B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 13 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory13B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 13 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback13B5 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback13B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 13 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback13B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback13B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 13 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback13B5
    : public XorpConstMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback13B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback13B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 13 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback13B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback13B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback13B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback13B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback13B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback13B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback13B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory13B5
{
    static XorpConstMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback13B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 13 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory13B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 13 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory13B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 13 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback13B6 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback13B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 13 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback13B6<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback13B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 13 dispatch time arguments and 6 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr(new XorpFunctionCallback13B6<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 13 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback13B6 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback13B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 13 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback13B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback13B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 13 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback13B6
    : public XorpMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback13B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback13B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 13 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback13B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback13B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback13B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback13B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback13B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback13B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback13B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory13B6
{
    static XorpMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 13 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory13B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 13 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory13B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 13 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback13B6 : public XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback13B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 13 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback13B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback13B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback13<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 13 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback13B6
    : public XorpConstMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback13B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback13B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 13 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback13B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback13B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback13B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback13B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback13B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback13B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback13B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory13B6
{
    static XorpConstMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback13B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 13 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory13B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 13 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback13<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory13B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 14 late args
//

/**
 * @short Base class for callbacks with 14 dispatch time args.
 */
template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
struct XorpCallback14 {
    typedef ref_ptr<XorpCallback14> RefPtr;

    XorpCallback14(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback14() {}
    virtual R dispatch(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 14 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
struct XorpFunctionCallback14B0 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
    XorpFunctionCallback14B0(const char* file, int line, F f)
	: XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _f(f)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 14 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
struct XorpFunctionCallback14B0<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> : public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
    XorpFunctionCallback14B0(const char* file, int line, F f)
	: XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _f(f)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 14 dispatch time arguments and 0 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)) {
    return typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr(new XorpFunctionCallback14B0<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line, f));
}

/**
 * @short Callback object for member methods with 14 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
struct XorpMemberCallback14B0 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ;
    XorpMemberCallback14B0(const char* file, int line, O* o, M m)
	 : XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 14 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
struct XorpMemberCallback14B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>
: public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ;
    XorpMemberCallback14B0(const char* file, int line, O* o, M m)
	 : XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 14 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
struct XorpSafeMemberCallback14B0
    : public XorpMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::M M;
    XorpSafeMemberCallback14B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback14B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 14 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
struct XorpSafeMemberCallback14B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>
    : public XorpMemberCallback14B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback14B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::M M;
    XorpSafeMemberCallback14B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback14B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback14B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback14B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, bool B=true>
struct XorpMemberCallbackFactory14B0
{
    static XorpMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))
    {
	return new XorpSafeMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
struct XorpMemberCallbackFactory14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, false>
{
    static XorpMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))
    {
	return new XorpMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 14 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))
{
    return XorpMemberCallbackFactory14B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 14 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))
{
    return XorpMemberCallbackFactory14B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 14 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
struct XorpConstMemberCallback14B0 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)  const;
    XorpConstMemberCallback14B0(const char* file, int line, O* o, M m)
	 : XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 14 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
struct XorpConstMemberCallback14B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>
: public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)  const;
    XorpConstMemberCallback14B0(const char* file, int line, O* o, M m)
	 : XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 14 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
struct XorpConstSafeMemberCallback14B0
    : public XorpConstMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::M M;
    XorpConstSafeMemberCallback14B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback14B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 14 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
struct XorpConstSafeMemberCallback14B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>
    : public XorpConstMemberCallback14B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback14B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::M M;
    XorpConstSafeMemberCallback14B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback14B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback14B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback14B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, bool B=true>
struct XorpConstMemberCallbackFactory14B0
{
    static XorpConstMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const)
    {
	return new XorpConstSafeMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14>
struct XorpConstMemberCallbackFactory14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, false>
{
    static XorpConstMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const)
    {
	return new XorpConstMemberCallback14B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 14 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const)
{
    return XorpConstMemberCallbackFactory14B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 14 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const)
{
    return XorpConstMemberCallbackFactory14B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 14 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1>
struct XorpFunctionCallback14B1 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1);
    XorpFunctionCallback14B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 14 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1>
struct XorpFunctionCallback14B1<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1> : public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1);
    XorpFunctionCallback14B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 14 dispatch time arguments and 1 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1>
typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1), BA1 ba1) {
    return typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr(new XorpFunctionCallback14B1<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 14 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1>
struct XorpMemberCallback14B1 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1) ;
    XorpMemberCallback14B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 14 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1>
struct XorpMemberCallback14B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>
: public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1) ;
    XorpMemberCallback14B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 14 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1>
struct XorpSafeMemberCallback14B1
    : public XorpMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>::M M;
    XorpSafeMemberCallback14B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback14B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 14 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1>
struct XorpSafeMemberCallback14B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>
    : public XorpMemberCallback14B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback14B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>::M M;
    XorpSafeMemberCallback14B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback14B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback14B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback14B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, bool B=true>
struct XorpMemberCallbackFactory14B1
{
    static XorpMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1>
struct XorpMemberCallbackFactory14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, false>
{
    static XorpMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1), BA1 ba1)
    {
	return new XorpMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 14 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory14B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 14 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory14B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 14 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1>
struct XorpConstMemberCallback14B1 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1)  const;
    XorpConstMemberCallback14B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 14 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1>
struct XorpConstMemberCallback14B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>
: public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1)  const;
    XorpConstMemberCallback14B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 14 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1>
struct XorpConstSafeMemberCallback14B1
    : public XorpConstMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>::M M;
    XorpConstSafeMemberCallback14B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback14B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 14 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1>
struct XorpConstSafeMemberCallback14B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>
    : public XorpConstMemberCallback14B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback14B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>::M M;
    XorpConstSafeMemberCallback14B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback14B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback14B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback14B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory14B1
{
    static XorpConstMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1>
struct XorpConstMemberCallbackFactory14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, false>
{
    static XorpConstMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback14B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 14 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory14B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 14 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory14B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 14 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2>
struct XorpFunctionCallback14B2 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2);
    XorpFunctionCallback14B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 14 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2>
struct XorpFunctionCallback14B2<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2> : public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2);
    XorpFunctionCallback14B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 14 dispatch time arguments and 2 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2>
typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr(new XorpFunctionCallback14B2<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 14 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2>
struct XorpMemberCallback14B2 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2) ;
    XorpMemberCallback14B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 14 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2>
struct XorpMemberCallback14B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>
: public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2) ;
    XorpMemberCallback14B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 14 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2>
struct XorpSafeMemberCallback14B2
    : public XorpMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>::M M;
    XorpSafeMemberCallback14B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback14B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 14 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2>
struct XorpSafeMemberCallback14B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>
    : public XorpMemberCallback14B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback14B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>::M M;
    XorpSafeMemberCallback14B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback14B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback14B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback14B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory14B2
{
    static XorpMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2>
struct XorpMemberCallbackFactory14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, false>
{
    static XorpMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 14 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory14B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 14 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory14B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 14 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2>
struct XorpConstMemberCallback14B2 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2)  const;
    XorpConstMemberCallback14B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 14 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2>
struct XorpConstMemberCallback14B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>
: public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2)  const;
    XorpConstMemberCallback14B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 14 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2>
struct XorpConstSafeMemberCallback14B2
    : public XorpConstMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>::M M;
    XorpConstSafeMemberCallback14B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback14B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 14 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2>
struct XorpConstSafeMemberCallback14B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>
    : public XorpConstMemberCallback14B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback14B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>::M M;
    XorpConstSafeMemberCallback14B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback14B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback14B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback14B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory14B2
{
    static XorpConstMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2>
struct XorpConstMemberCallbackFactory14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, false>
{
    static XorpConstMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback14B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 14 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory14B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 14 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory14B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 14 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3>
struct XorpFunctionCallback14B3 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3);
    XorpFunctionCallback14B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 14 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3>
struct XorpFunctionCallback14B3<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3> : public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3);
    XorpFunctionCallback14B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 14 dispatch time arguments and 3 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3>
typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr(new XorpFunctionCallback14B3<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 14 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3>
struct XorpMemberCallback14B3 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3) ;
    XorpMemberCallback14B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 14 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3>
struct XorpMemberCallback14B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>
: public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3) ;
    XorpMemberCallback14B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 14 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback14B3
    : public XorpMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback14B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback14B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 14 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback14B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>
    : public XorpMemberCallback14B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback14B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback14B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback14B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback14B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback14B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory14B3
{
    static XorpMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, false>
{
    static XorpMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 14 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory14B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 14 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory14B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 14 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback14B3 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3)  const;
    XorpConstMemberCallback14B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 14 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback14B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>
: public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3)  const;
    XorpConstMemberCallback14B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 14 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback14B3
    : public XorpConstMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback14B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback14B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 14 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback14B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>
    : public XorpConstMemberCallback14B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback14B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback14B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback14B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback14B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback14B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory14B3
{
    static XorpConstMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback14B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 14 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory14B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 14 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory14B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 14 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback14B4 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4);
    XorpFunctionCallback14B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 14 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback14B4<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4> : public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4);
    XorpFunctionCallback14B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 14 dispatch time arguments and 4 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr(new XorpFunctionCallback14B4<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 14 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback14B4 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback14B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 14 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback14B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>
: public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback14B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 14 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback14B4
    : public XorpMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback14B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback14B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 14 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback14B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback14B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback14B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback14B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback14B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback14B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback14B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory14B4
{
    static XorpMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 14 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory14B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 14 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory14B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 14 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback14B4 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback14B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 14 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback14B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>
: public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback14B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 14 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback14B4
    : public XorpConstMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback14B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback14B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 14 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback14B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback14B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback14B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback14B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback14B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback14B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback14B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory14B4
{
    static XorpConstMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback14B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 14 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory14B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 14 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory14B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 14 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback14B5 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback14B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 14 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback14B5<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5> : public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback14B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 14 dispatch time arguments and 5 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr(new XorpFunctionCallback14B5<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 14 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback14B5 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback14B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 14 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback14B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback14B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 14 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback14B5
    : public XorpMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback14B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback14B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 14 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback14B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback14B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback14B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback14B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback14B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback14B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback14B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory14B5
{
    static XorpMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 14 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory14B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 14 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory14B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 14 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback14B5 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback14B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 14 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback14B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback14B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 14 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback14B5
    : public XorpConstMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback14B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback14B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 14 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback14B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback14B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback14B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback14B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback14B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback14B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback14B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory14B5
{
    static XorpConstMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback14B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 14 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory14B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 14 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory14B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 14 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback14B6 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback14B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 14 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback14B6<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback14B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 14 dispatch time arguments and 6 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr(new XorpFunctionCallback14B6<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 14 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback14B6 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback14B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 14 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback14B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback14B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 14 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback14B6
    : public XorpMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback14B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback14B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 14 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback14B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback14B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback14B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback14B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback14B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback14B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback14B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory14B6
{
    static XorpMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 14 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory14B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 14 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory14B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 14 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback14B6 : public XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback14B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 14 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback14B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback14B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback14<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 14 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback14B6
    : public XorpConstMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback14B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback14B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 14 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback14B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback14B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback14B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback14B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback14B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback14B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback14B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory14B6
{
    static XorpConstMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback14B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 14 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory14B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 14 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback14<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory14B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


///////////////////////////////////////////////////////////////////////////////
//
// Code relating to callbacks with 15 late args
//

/**
 * @short Base class for callbacks with 15 dispatch time args.
 */
template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
struct XorpCallback15 {
    typedef ref_ptr<XorpCallback15> RefPtr;

    XorpCallback15(const char* file, int line)
	: _file(file), _line(line) {}
    virtual ~XorpCallback15() {}
    virtual R dispatch(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) = 0;
    const char* file() const		{ return _file; }
    int line() const			{ return _line; }
private:
    const char* _file;
    int         _line;
};

/**
 * @short Callback object for functions with 15 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
struct XorpFunctionCallback15B0 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
    XorpFunctionCallback15B0(const char* file, int line, F f)
	: XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _f(f)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
};


/**
 * @short Callback object for void functions with 15 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
struct XorpFunctionCallback15B0<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> : public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
    XorpFunctionCallback15B0(const char* file, int line, F f)
	: XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _f(f)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	record_dispatch_leave();
    }
protected:
    F   _f;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 15 dispatch time arguments and 0 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)) {
    return typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr(new XorpFunctionCallback15B0<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line, f));
}

/**
 * @short Callback object for member methods with 15 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
struct XorpMemberCallback15B0 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ;
    XorpMemberCallback15B0(const char* file, int line, O* o, M m)
	 : XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void member methods with 15 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
struct XorpMemberCallback15B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>
: public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ;
    XorpMemberCallback15B0(const char* file, int line, O* o, M m)
	 : XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for safe member methods with 15 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
struct XorpSafeMemberCallback15B0
    : public XorpMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::M M;
    XorpSafeMemberCallback15B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback15B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 15 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
struct XorpSafeMemberCallback15B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>
    : public XorpMemberCallback15B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback15B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::M M;
    XorpSafeMemberCallback15B0(const char* file, int line, O* o, M m)
	 : XorpMemberCallback15B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback15B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback15B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, bool B=true>
struct XorpMemberCallbackFactory15B0
{
    static XorpMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))
    {
	return new XorpSafeMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
struct XorpMemberCallbackFactory15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, false>
{
    static XorpMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))
    {
	return new XorpMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 15 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))
{
    return XorpMemberCallbackFactory15B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 15 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))
{
    return XorpMemberCallbackFactory15B0<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for const member methods with 15 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
struct XorpConstMemberCallback15B0 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)  const;
    XorpConstMemberCallback15B0(const char* file, int line, O* o, M m)
	 : XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for void const member methods with 15 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
struct XorpConstMemberCallback15B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>
: public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)  const;
    XorpConstMemberCallback15B0(const char* file, int line, O* o, M m)
	 : XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
};

/**
 * @short Callback object for const safe member methods with 15 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
struct XorpConstSafeMemberCallback15B0
    : public XorpConstMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::M M;
    XorpConstSafeMemberCallback15B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback15B0() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 15 dispatch time
 * arguments and 0 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
struct XorpConstSafeMemberCallback15B0<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>
    : public XorpConstMemberCallback15B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback15B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::M M;
    XorpConstSafeMemberCallback15B0(const char* file, int line, O* o, M m)
	 : XorpConstMemberCallback15B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line, o, m),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback15B0() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback15B0<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, bool B=true>
struct XorpConstMemberCallbackFactory15B0
{
    static XorpConstMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) const)
    {
	return new XorpConstSafeMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line, o, p);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15>
struct XorpConstMemberCallbackFactory15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, false>
{
    static XorpConstMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) const)
    {
	return new XorpConstMemberCallback15B0<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line, o, p);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 15 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) const)
{
    return XorpConstMemberCallbackFactory15B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 15 dispatch time arguments and 0 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) const)
{
    return XorpConstMemberCallbackFactory15B0<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p);
}


/**
 * @short Callback object for functions with 15 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1>
struct XorpFunctionCallback15B1 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1);
    XorpFunctionCallback15B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _f(f), _ba1(ba1)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * @short Callback object for void functions with 15 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1>
struct XorpFunctionCallback15B1<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1> : public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1);
    XorpFunctionCallback15B1(const char* file, int line, F f, BA1 ba1)
	: XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _f(f), _ba1(ba1)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 15 dispatch time arguments and 1 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1>
typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1), BA1 ba1) {
    return typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr(new XorpFunctionCallback15B1<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>(file, line, f, ba1));
}

/**
 * @short Callback object for member methods with 15 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1>
struct XorpMemberCallback15B1 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1) ;
    XorpMemberCallback15B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void member methods with 15 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1>
struct XorpMemberCallback15B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>
: public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1) ;
    XorpMemberCallback15B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 15 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1>
struct XorpSafeMemberCallback15B1
    : public XorpMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>::M M;
    XorpSafeMemberCallback15B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback15B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 15 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1>
struct XorpSafeMemberCallback15B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>
    : public XorpMemberCallback15B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback15B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>::M M;
    XorpSafeMemberCallback15B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpMemberCallback15B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback15B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback15B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, bool B=true>
struct XorpMemberCallbackFactory15B1
{
    static XorpMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1), BA1 ba1)
    {
	return new XorpSafeMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1>
struct XorpMemberCallbackFactory15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, false>
{
    static XorpMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1), BA1 ba1)
    {
	return new XorpMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 15 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory15B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 15 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1), BA1 ba1)
{
    return XorpMemberCallbackFactory15B1<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for const member methods with 15 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1>
struct XorpConstMemberCallback15B1 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1)  const;
    XorpConstMemberCallback15B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 15 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1>
struct XorpConstMemberCallback15B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>
: public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1)  const;
    XorpConstMemberCallback15B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 15 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1>
struct XorpConstSafeMemberCallback15B1
    : public XorpConstMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>::M M;
    XorpConstSafeMemberCallback15B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback15B1() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 15 dispatch time
 * arguments and 1 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1>
struct XorpConstSafeMemberCallback15B1<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>
    : public XorpConstMemberCallback15B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback15B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>::M M;
    XorpConstSafeMemberCallback15B1(const char* file, int line, O* o, M m, BA1 ba1)
	 : XorpConstMemberCallback15B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>(file, line, o, m, ba1),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback15B1() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback15B1<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, bool B=true>
struct XorpConstMemberCallbackFactory15B1
{
    static XorpConstMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1) const, BA1 ba1)
    {
	return new XorpConstSafeMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>(file, line, o, p, ba1);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1>
struct XorpConstMemberCallbackFactory15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, false>
{
    static XorpConstMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1) const, BA1 ba1)
    {
	return new XorpConstMemberCallback15B1<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1>(file, line, o, p, ba1);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 15 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory15B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 15 dispatch time arguments and 1 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1) const, BA1 ba1)
{
    return XorpConstMemberCallbackFactory15B1<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1);
}


/**
 * @short Callback object for functions with 15 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2>
struct XorpFunctionCallback15B2 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2);
    XorpFunctionCallback15B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * @short Callback object for void functions with 15 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2>
struct XorpFunctionCallback15B2<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2> : public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2);
    XorpFunctionCallback15B2(const char* file, int line, F f, BA1 ba1, BA2 ba2)
	: XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 15 dispatch time arguments and 2 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2>
typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2), BA1 ba1, BA2 ba2) {
    return typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr(new XorpFunctionCallback15B2<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>(file, line, f, ba1, ba2));
}

/**
 * @short Callback object for member methods with 15 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2>
struct XorpMemberCallback15B2 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2) ;
    XorpMemberCallback15B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void member methods with 15 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2>
struct XorpMemberCallback15B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>
: public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2) ;
    XorpMemberCallback15B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 15 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2>
struct XorpSafeMemberCallback15B2
    : public XorpMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>::M M;
    XorpSafeMemberCallback15B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback15B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 15 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2>
struct XorpSafeMemberCallback15B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>
    : public XorpMemberCallback15B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback15B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>::M M;
    XorpSafeMemberCallback15B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpMemberCallback15B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback15B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback15B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, bool B=true>
struct XorpMemberCallbackFactory15B2
{
    static XorpMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpSafeMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2>
struct XorpMemberCallbackFactory15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, false>
{
    static XorpMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2), BA1 ba1, BA2 ba2)
    {
	return new XorpMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 15 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory15B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 15 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2), BA1 ba1, BA2 ba2)
{
    return XorpMemberCallbackFactory15B2<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for const member methods with 15 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2>
struct XorpConstMemberCallback15B2 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2)  const;
    XorpConstMemberCallback15B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 15 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2>
struct XorpConstMemberCallback15B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>
: public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2)  const;
    XorpConstMemberCallback15B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 15 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2>
struct XorpConstSafeMemberCallback15B2
    : public XorpConstMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>::M M;
    XorpConstSafeMemberCallback15B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback15B2() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 15 dispatch time
 * arguments and 2 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2>
struct XorpConstSafeMemberCallback15B2<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>
    : public XorpConstMemberCallback15B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback15B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>::M M;
    XorpConstSafeMemberCallback15B2(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2)
	 : XorpConstMemberCallback15B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>(file, line, o, m, ba1, ba2),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback15B2() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback15B2<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, bool B=true>
struct XorpConstMemberCallbackFactory15B2
{
    static XorpConstMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstSafeMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>(file, line, o, p, ba1, ba2);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2>
struct XorpConstMemberCallbackFactory15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, false>
{
    static XorpConstMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2) const, BA1 ba1, BA2 ba2)
    {
	return new XorpConstMemberCallback15B2<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2>(file, line, o, p, ba1, ba2);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 15 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory15B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 15 dispatch time arguments and 2 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2) const, BA1 ba1, BA2 ba2)
{
    return XorpConstMemberCallbackFactory15B2<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2);
}


/**
 * @short Callback object for functions with 15 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3>
struct XorpFunctionCallback15B3 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3);
    XorpFunctionCallback15B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * @short Callback object for void functions with 15 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3>
struct XorpFunctionCallback15B3<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3> : public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3);
    XorpFunctionCallback15B3(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3)
	: XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 15 dispatch time arguments and 3 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3>
typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3) {
    return typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr(new XorpFunctionCallback15B3<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>(file, line, f, ba1, ba2, ba3));
}

/**
 * @short Callback object for member methods with 15 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3>
struct XorpMemberCallback15B3 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3) ;
    XorpMemberCallback15B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void member methods with 15 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3>
struct XorpMemberCallback15B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>
: public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3) ;
    XorpMemberCallback15B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 15 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback15B3
    : public XorpMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback15B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback15B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 15 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3>
struct XorpSafeMemberCallback15B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>
    : public XorpMemberCallback15B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback15B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>::M M;
    XorpSafeMemberCallback15B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpMemberCallback15B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback15B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback15B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, bool B=true>
struct XorpMemberCallbackFactory15B3
{
    static XorpMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpSafeMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3>
struct XorpMemberCallbackFactory15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, false>
{
    static XorpMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 15 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory15B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 15 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3), BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpMemberCallbackFactory15B3<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for const member methods with 15 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback15B3 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3)  const;
    XorpConstMemberCallback15B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 15 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3>
struct XorpConstMemberCallback15B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>
: public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3)  const;
    XorpConstMemberCallback15B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 15 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback15B3
    : public XorpConstMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback15B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback15B3() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 15 dispatch time
 * arguments and 3 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3>
struct XorpConstSafeMemberCallback15B3<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>
    : public XorpConstMemberCallback15B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback15B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>::M M;
    XorpConstSafeMemberCallback15B3(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3)
	 : XorpConstMemberCallback15B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>(file, line, o, m, ba1, ba2, ba3),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback15B3() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback15B3<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, bool B=true>
struct XorpConstMemberCallbackFactory15B3
{
    static XorpConstMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstSafeMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3>
struct XorpConstMemberCallbackFactory15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, false>
{
    static XorpConstMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
    {
	return new XorpConstMemberCallback15B3<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3>(file, line, o, p, ba1, ba2, ba3);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 15 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory15B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 15 dispatch time arguments and 3 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3) const, BA1 ba1, BA2 ba2, BA3 ba3)
{
    return XorpConstMemberCallbackFactory15B3<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3);
}


/**
 * @short Callback object for functions with 15 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback15B4 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4);
    XorpFunctionCallback15B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * @short Callback object for void functions with 15 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4>
struct XorpFunctionCallback15B4<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4> : public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4);
    XorpFunctionCallback15B4(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	: XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 15 dispatch time arguments and 4 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4>
typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4) {
    return typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr(new XorpFunctionCallback15B4<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>(file, line, f, ba1, ba2, ba3, ba4));
}

/**
 * @short Callback object for member methods with 15 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback15B4 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback15B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void member methods with 15 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallback15B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>
: public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4) ;
    XorpMemberCallback15B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 15 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback15B4
    : public XorpMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback15B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback15B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 15 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4>
struct XorpSafeMemberCallback15B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>
    : public XorpMemberCallback15B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback15B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>::M M;
    XorpSafeMemberCallback15B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpMemberCallback15B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback15B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback15B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpMemberCallbackFactory15B4
{
    static XorpMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpSafeMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4>
struct XorpMemberCallbackFactory15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, false>
{
    static XorpMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 15 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory15B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 15 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpMemberCallbackFactory15B4<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for const member methods with 15 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback15B4 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback15B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 15 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallback15B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>
: public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4)  const;
    XorpConstMemberCallback15B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 15 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback15B4
    : public XorpConstMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback15B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback15B4() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 15 dispatch time
 * arguments and 4 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4>
struct XorpConstSafeMemberCallback15B4<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>
    : public XorpConstMemberCallback15B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback15B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>::M M;
    XorpConstSafeMemberCallback15B4(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
	 : XorpConstMemberCallback15B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>(file, line, o, m, ba1, ba2, ba3, ba4),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback15B4() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback15B4<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, bool B=true>
struct XorpConstMemberCallbackFactory15B4
{
    static XorpConstMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstSafeMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4>
struct XorpConstMemberCallbackFactory15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, false>
{
    static XorpConstMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
    {
	return new XorpConstMemberCallback15B4<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4>(file, line, o, p, ba1, ba2, ba3, ba4);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 15 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory15B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 15 dispatch time arguments and 4 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4)
{
    return XorpConstMemberCallbackFactory15B4<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4);
}


/**
 * @short Callback object for functions with 15 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback15B5 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback15B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * @short Callback object for void functions with 15 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpFunctionCallback15B5<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5> : public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5);
    XorpFunctionCallback15B5(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	: XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 15 dispatch time arguments and 5 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5>
typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5) {
    return typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr(new XorpFunctionCallback15B5<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>(file, line, f, ba1, ba2, ba3, ba4, ba5));
}

/**
 * @short Callback object for member methods with 15 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback15B5 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback15B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void member methods with 15 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallback15B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5) ;
    XorpMemberCallback15B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 15 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback15B5
    : public XorpMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback15B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback15B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 15 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpSafeMemberCallback15B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>
    : public XorpMemberCallback15B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback15B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpSafeMemberCallback15B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpMemberCallback15B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback15B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback15B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpMemberCallbackFactory15B5
{
    static XorpMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpSafeMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpMemberCallbackFactory15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 15 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory15B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 15 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpMemberCallbackFactory15B5<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for const member methods with 15 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback15B5 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback15B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 15 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallback15B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>
: public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5)  const;
    XorpConstMemberCallback15B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4, _ba5);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 15 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback15B5
    : public XorpConstMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback15B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback15B5() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 15 dispatch time
 * arguments and 5 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstSafeMemberCallback15B5<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>
    : public XorpConstMemberCallback15B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback15B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>::M M;
    XorpConstSafeMemberCallback15B5(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
	 : XorpConstMemberCallback15B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>(file, line, o, m, ba1, ba2, ba3, ba4, ba5),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback15B5() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback15B5<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, bool B=true>
struct XorpConstMemberCallbackFactory15B5
{
    static XorpConstMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstSafeMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5>
struct XorpConstMemberCallbackFactory15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, false>
{
    static XorpConstMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
    {
	return new XorpConstMemberCallback15B5<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5>(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 15 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory15B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 15 dispatch time arguments and 5 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5)
{
    return XorpConstMemberCallbackFactory15B5<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5);
}


/**
 * @short Callback object for functions with 15 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback15B6 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback15B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = (*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * @short Callback object for void functions with 15 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpFunctionCallback15B6<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6> : public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (*F)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6);
    XorpFunctionCallback15B6(const char* file, int line, F f, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	: XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _f(f), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6)
    {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	(*_f)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    F   _f;
    BA1 _ba1;
    BA2 _ba2;
    BA3 _ba3;
    BA4 _ba4;
    BA5 _ba5;
    BA6 _ba6;
};


/**
 * Factory function that creates a callback object targetted at a
 * function with 15 dispatch time arguments and 6 bound arguments.
 */
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line, R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6) {
    return typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr(new XorpFunctionCallback15B6<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, f, ba1, ba2, ba3, ba4, ba5, ba6));
}

/**
 * @short Callback object for member methods with 15 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback15B6 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback15B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void member methods with 15 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallback15B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6) ;
    XorpMemberCallback15B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for safe member methods with 15 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback15B6
    : public XorpMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback15B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback15B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void safe member methods with 15 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpSafeMemberCallback15B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpMemberCallback15B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpMemberCallback15B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpSafeMemberCallback15B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpMemberCallback15B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpSafeMemberCallback15B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpMemberCallback15B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpMemberCallbackFactory15B6
{
    static XorpMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpSafeMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpMemberCallbackFactory15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * member function with 15 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory15B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * member function with 15 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6), BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpMemberCallbackFactory15B6<R,  O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


/**
 * @short Callback object for const member methods with 15 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback15B6 : public XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef R (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback15B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	R r = ((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
	return r;
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for void const member methods with 15 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallback15B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>
: public XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
    typedef void (O::*M)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6)  const;
    XorpConstMemberCallback15B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpCallback15<void, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(file, line),
	  _o(o), _m(m), _ba1(ba1), _ba2(ba2), _ba3(ba3), _ba4(ba4), _ba5(ba5), _ba6(ba6) {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	record_dispatch_enter();
	((*_o).*_m)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, _ba1, _ba2, _ba3, _ba4, _ba5, _ba6);
	record_dispatch_leave();
    }
protected:
    O*	_o;	// Callback's target object
    M	_m;	// Callback's target method
    BA1 _ba1;	// Bound argument
    BA2 _ba2;	// Bound argument
    BA3 _ba3;	// Bound argument
    BA4 _ba4;	// Bound argument
    BA5 _ba5;	// Bound argument
    BA6 _ba6;	// Bound argument
};

/**
 * @short Callback object for const safe member methods with 15 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback15B6
    : public XorpConstMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback15B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback15B6() {}
    R dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    R r = XorpConstMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	    return r;
	}
    }
};

/**
 * @short Callback object for void const safe member methods with 15 dispatch time
 * arguments and 6 bound (stored) arguments.
 */
template <class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstSafeMemberCallback15B6<void,O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>
    : public XorpConstMemberCallback15B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>,
      public SafeCallbackBase {
    typedef typename XorpConstMemberCallback15B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>::M M;
    XorpConstSafeMemberCallback15B6(const char* file, int line, O* o, M m, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
	 : XorpConstMemberCallback15B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, m, ba1, ba2, ba3, ba4, ba5, ba6),
	   SafeCallbackBase(o) {}
    ~XorpConstSafeMemberCallback15B6() {}
    void dispatch(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) {
	if (valid()) {
	    record_dispatch_enter();
	    XorpConstMemberCallback15B6<void, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>::dispatch(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
	    record_dispatch_leave();
	}
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6, bool B=true>
struct XorpConstMemberCallbackFactory15B6
{
    static XorpConstMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstSafeMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    }
};

template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6>
struct XorpConstMemberCallbackFactory15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6, false>
{
    static XorpConstMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>*
    make(const char* file, int line, O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
    {
	return new XorpConstMemberCallback15B6<R, O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6>(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
    };
};

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 15 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  const O* o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory15B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}

/**
 * Factory function that creates a callback object targetted at a
 * const member function with 15 dispatch time arguments and 6 bound arguments.
 */
template <class R, class O, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class BA1, class BA2, class BA3, class BA4, class BA5, class BA6> typename XorpCallback15<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>::RefPtr
dbg_callback(const char* file, int line,  const O& o, R (O::*p)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6) const, BA1 ba1, BA2 ba2, BA3 ba3, BA4 ba4, BA5 ba5, BA6 ba6)
{
    return XorpConstMemberCallbackFactory15B6<R,  const O, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, BA1, BA2, BA3, BA4, BA5, BA6, BaseAndDerived<CallbackSafeObject, O>::True>::make(file, line, &o, p, ba1, ba2, ba3, ba4, ba5, ba6);
}


#endif /* __XORP_CALLBACK_HH__ */
