//genMethods "-g" "-t" "char*" "-h" "Array" "-I" "LINK/basic/Array.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Array.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ArrayWrapper.h>


typedef char* _char_;
typedef Array<char* > _Array_char__;

#define _Array_char__DATA(x) ((Array<char* >*) (EXTDATA(x)))
#define _Array_char__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Array<char* > >::type))
#define _Array_char__ISNT_DATA(x) (!IS_DATA(x))

#define _Array_char__CXX_DATA(x) (*(Array<char* >*) (EXTDATA(VAL(x))))
#define _Array_char__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Array<char* > >::type))
#define _Array_char__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Array_char__Methods() {}

//genMethods "-g" "-t" "int*" "-h" "Array" "-I" "LINK/basic/Array.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Array.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ArrayWrapper.h>


typedef int* _int_;
typedef Array<int* > _Array_int__;

#define _Array_int__DATA(x) ((Array<int* >*) (EXTDATA(x)))
#define _Array_int__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Array<int* > >::type))
#define _Array_int__ISNT_DATA(x) (!IS_DATA(x))

#define _Array_int__CXX_DATA(x) (*(Array<int* >*) (EXTDATA(VAL(x))))
#define _Array_int__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Array<int* > >::type))
#define _Array_int__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

PRIMITIVE intVector2STkList(SCM l)
{
        SCM z;

        if  (CXX_NTYPEP(l, Wrapper<Array<int*> >::type))
                Err("typed-list-convert: wrong type of argument", l);
        Array<int*> *lp = (Array<int*>*) CLASSDATA(l);
        Iterator<int*> get_next(lp);
        int *e;
        if (get_next(e)) {
                SCM new_el = STk_makeinteger(*e);
                SCM tail, head;
                NEWCELL(tail, tc_cons);
                CAR(tail) = new_el;
                CDR(tail) = NIL;
                head = tail;
                SCM z;
                while (get_next(e)) {
                        SCM new_el  = STk_makeinteger(*e);
                        NEWCELL(z, tc_cons);
                        CAR(z) = new_el;
                        CDR(z) = NIL;
                        CDR(tail) = z;
                        tail = z;
                }
                return head;
        }
        return NIL;
}

PRIMITIVE fillIntVector(SCM v, SCM e)
{
        SCM ne = MakeIntCmd(e);
        return ArrayWrapper<int*>::fillLinkArray(v, ne);
}

PRIMITIVE setIntVector(SCM v, SCM i, SCM e)
{
        SCM ne = MakeIntCmd(e);
        return ArrayWrapper<int*>::setLinkArray(v, i, ne);
}



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Array_int__Methods() 
{
        STk_add_new_cpp_primitive("vector-int->list2", tc_subr_1,
        (PRIMITIVE (*)(...))  intVector2STkList);
        STk_add_new_cpp_primitive("Vector-int-vector-set2!", tc_subr_3,
        (PRIMITIVE (*)(...))  setIntVector);
        STk_add_new_cpp_primitive("Vector-int-vector-fill2!", tc_subr_2,
        (PRIMITIVE (*)(...))  fillIntVector);


        //addOneArgMethod("vector-int->list",
        //        Wrapper<_Array_int__ >::name,
        //        "vector-int->list2", LINK_OVL);

        //addThreeArgMethod("vector-set!",
        //        Wrapper<_Array_int__ >::name,
        //        "<integer>",
        //        "<integer>",
        //        "Vector-int-vector-set2!", LINK_OVL);
        //addTwoArgMethod("vector-fill!",
        //        Wrapper<_Array_int__ >::name,
        //        "<integer>",
        //        "Vector-int-vector-fill2!", LINK_OVL);

}
//genMethods "-g" "-t" "MSet<int*>" "-h" "Collection" "-I" "LINK/basic/SetFuncs.h" "-I" "LINK/basic/Set.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/SetFuncs.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef MSet<int*> _MSet_int__;
typedef Collection<MSet<int*> > _Collection_MSet_int___;

#define _Collection_MSet_int___DATA(x) ((Collection<MSet<int*> >*) (EXTDATA(x)))
#define _Collection_MSet_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<MSet<int*> > >::type))
#define _Collection_MSet_int___ISNT_DATA(x) (!IS_DATA(x))

#define _Collection_MSet_int___CXX_DATA(x) (*(Collection<MSet<int*> >*) (EXTDATA(VAL(x))))
#define _Collection_MSet_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<MSet<int*> > >::type))
#define _Collection_MSet_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Collection_MSet_int___Methods() {}

//genMethods "-g" "-t" "Sequence<int*>" "-h" "Collection" "-c" "int*" "-I" "LINK/stkWrapper/SetFuncsWrapper.h" "-I" "LINK/basic/SetFuncs.h" "-I" "LINK/basic/Sequence.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/stkWrapper/SetFuncsWrapper.h>

#include <LINK/basic/SetFuncs.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Sequence<int*> _Sequence_int__;
typedef Collection<Sequence<int*> > _Collection_Sequence_int___;

#define _Collection_Sequence_int___DATA(x) ((Collection<Sequence<int*> >*) (EXTDATA(x)))
#define _Collection_Sequence_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Sequence<int*> > >::type))
#define _Collection_Sequence_int___ISNT_DATA(x) (!_Collection_Sequence_int___IS_DATA(x))

#define _Collection_Sequence_int___CXX_DATA(x) (*(Collection<Sequence<int*> >*) (EXTDATA(VAL(x))))
#define _Collection_Sequence_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Sequence<int*> > >::type))
#define _Collection_Sequence_int___CXX_ISNT_DATA(x) (!_Collection_Sequence_int___CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Collection_Sequence_int___Methods() {}
//genMethods "-g" "-t" "Set<char*>" "-h" "Collection" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/SetFuncs.h" "-I" "LINK/basic/Collection.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/SetFuncs.h>

#include <LINK/basic/Collection.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Set<char*> _Set_char__;
typedef Collection<Set<char*> > _Collection_Set_char___;

#define _Collection_Set_char___DATA(x) ((Collection<Set<char*> >*) (EXTDATA(x)))
#define _Collection_Set_char___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Set<char*> > >::type))
#define _Collection_Set_char___ISNT_DATA(x) (!IS_DATA(x))

#define _Collection_Set_char___CXX_DATA(x) (*(Collection<Set<char*> >*) (EXTDATA(VAL(x))))
#define _Collection_Set_char___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Set<char*> > >::type))
#define _Collection_Set_char___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Collection_Set_char___Methods() {}

//genMethods "-g" "-t" "Set<int*>" "-h" "Collection" "-c" "int*" "-I" "LINK/stkWrapper/SetFuncsWrapper.h" "-I" "LINK/basic/SetFuncs.h" "-I" "LINK/basic/Set.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/stkWrapper/SetFuncsWrapper.h>

#include <LINK/basic/SetFuncs.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Set<int*> _Set_int__;
typedef Collection<Set<int*> > _Collection_Set_int___;

#define _Collection_Set_int___DATA(x) ((Collection<Set<int*> >*) (EXTDATA(x)))
#define _Collection_Set_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Set<int*> > >::type))
#define _Collection_Set_int___ISNT_DATA(x) (!IS_DATA(x))

#define _Collection_Set_int___CXX_DATA(x) (*(Collection<Set<int*> >*) (EXTDATA(VAL(x))))
#define _Collection_Set_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Set<int*> > >::type))
#define _Collection_Set_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Collection_Set_int___Methods() {}

//genMethods "-t" "SubSet<int*>" "-h" "Collection" "-I" "LINK/basic/SetFuncs.h" "-I" "LINK/basic/Subset.h" "-I" "LINK/basic/Set.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/SetFuncs.h>

#include <LINK/basic/Subset.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef SubSet<int*> _SubSet_int__;
typedef Collection<SubSet<int*> > _Collection_SubSet_int___;

#define _Collection_SubSet_int___DATA(x) ((Collection<SubSet<int*> >*) (EXTDATA(x)))
#define _Collection_SubSet_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<SubSet<int*> > >::type))
#define _Collection_SubSet_int___ISNT_DATA(x) (!IS_DATA(x))

#define _Collection_SubSet_int___CXX_DATA(x) (*(Collection<SubSet<int*> >*) (EXTDATA(VAL(x))))
#define _Collection_SubSet_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<SubSet<int*> > >::type))
#define _Collection_SubSet_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Collection_SubSet_int___Methods() {}

//genMethods "-g" "-t" "char*" "-h" "Collection" "-I" "LINK/basic/SetFuncs.h" "-I" "LINK/basic/Collection.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/SetFuncs.h>

#include <LINK/basic/Collection.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef char* _char_;
typedef Collection<char* > _Collection_char__;

#define _Collection_char__DATA(x) ((Collection<char* >*) (EXTDATA(x)))
#define _Collection_char__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<char* > >::type))
#define _Collection_char__ISNT_DATA(x) (!IS_DATA(x))

#define _Collection_char__CXX_DATA(x) (*(Collection<char* >*) (EXTDATA(VAL(x))))
#define _Collection_char__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<char* > >::type))
#define _Collection_char__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Collection_char__Methods() {}

//genMethods "-g" "-t" "int*" "-h" "Collection" "-I" "LINK/basic/SetFuncs.h" "-I" "LINK/basic/Collection.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/SetFuncs.h>

#include <LINK/basic/Collection.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef int* _int_;
typedef Collection<int* > _Collection_int__;

#define _Collection_int__DATA(x) ((Collection<int* >*) (EXTDATA(x)))
#define _Collection_int__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<int* > >::type))
#define _Collection_int__ISNT_DATA(x) (!IS_DATA(x))

#define _Collection_int__CXX_DATA(x) (*(Collection<int* >*) (EXTDATA(VAL(x))))
#define _Collection_int__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<int* > >::type))
#define _Collection_int__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

// the following specializations of CollectionWrapper methods
// allow   (mset-int 1 2 3) style in addition to the
// standard (mset-int (make-int 1) (make-int 2) (make-int 3))
#include <iostream.h>

static PRIMITIVE buildMSetInt(SCM l)
{
	SCM tmp, nl = NIL;
	SCM ne;
	SCM z;
        int len=0;      // to avoid having to call STK_length(& go thru l again)

	if (NCONSP(l)) 
		Err("mset-int: bad argument", l);
	if (NNULLP(l)) {
		for (tmp=l; tmp != NIL; tmp = CDR(tmp))  {
			ne = MakeIntCmd(CAR(tmp));
			NEWCELL(z, tc_cons);
			CAR(z) = ne;
			CDR(z) = nl;
			nl = z;
			len++;
		}
		nl = STk_reverse(nl);
		return	CollectionWrapper<int*>::buildMSet(nl);
	}
	return	CollectionWrapper<int*>::buildMSet(NIL);
}

static PRIMITIVE buildSetInt(SCM l, int len)
{
	SCM tmp, nl = NIL;
	SCM ne;
	SCM z;

	if (NNULLP(l)) {
		for (tmp=l; tmp != NIL; tmp = CDR(tmp))  {
			ne = MakeIntCmd(CAR(tmp));
			NEWCELL(z, tc_cons);
			CAR(z) = ne;
			CDR(z) = nl;
			nl = z;
		}
		nl = STk_reverse(nl);
		return	CollectionWrapper<int*>::buildSet(nl);
	}
	return	CollectionWrapper<int*>::buildSet(NIL);
}

static PRIMITIVE buildSequenceInt(SCM l, int len)
{
	SCM tmp, nl = NIL;
	SCM ne;
	SCM z;

	if (NNULLP(l)) {
		for (tmp=l; tmp != NIL; tmp = CDR(tmp))  {
			ne = MakeIntCmd(CAR(tmp));	// catches errors
			NEWCELL(z, tc_cons);
			CAR(z) = ne;
			CDR(z) = nl;
			nl = z;
		}
		nl = STk_reverse(nl);
		return	CollectionWrapper<int*>::buildSequence(nl);
	}
	return	CollectionWrapper<int*>::buildSequence(NIL);
}

PRIMITIVE intCollection2STkList(SCM l)
{
	SCM z;

	if (!CollectionWrapper<int*>::isCollection(l))
		Err("typed-collection-convert: wrong type of argument", l);
	Collection<int*> *cp = CollectionWrapper<int*>::getCollection(l);
	Iterator<int*> get_next(cp);
	int* e;
	if (get_next(e)) {
		SCM new_el = STk_makeinteger(*e);
		SCM tail, head;
		NEWCELL(tail, tc_cons);
		CAR(tail) = new_el;
		CDR(tail) = NIL;
		head = tail;
		SCM z;
		while (get_next(e)) {
			SCM new_el  = STk_makeinteger(*e);
			NEWCELL(z, tc_cons);
			CAR(z) = new_el;
			CDR(z) = NIL;
			CDR(tail) = z;
			tail = z;
		}
		return head;
	}
	return NIL;
}

PRIMITIVE memberLinkIntCollection(SCM e, SCM l)
{
	SCM ne = MakeIntCmd(e);
	return CollectionWrapper<int*>::memberLinkCollection(ne, l);
}

PRIMITIVE insertLinkIntCollection(SCM e, SCM l)
{
	SCM ne = MakeIntCmd(e);
	return CollectionWrapper<int*>::insertLinkCollection(ne, l);
}

PRIMITIVE appendLinkIntCollection(SCM e, SCM l)
{
	SCM ne = MakeIntCmd(e);
	return CollectionWrapper<int*>::appendLinkCollection(ne, l);
}

PRIMITIVE removeLinkIntCollection(SCM e, SCM l)
{
	SCM ne = MakeIntCmd(e);
	return CollectionWrapper<int*>::removeLinkCollection(ne, l);
}

PRIMITIVE occurrencesLinkIntCollection(SCM e, SCM l)
{
	SCM ne = MakeIntCmd(e);
	return CollectionWrapper<int*>::occurrencesLinkCollection(ne, l);
}

// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Collection_int__Methods() 
{
        STk_add_new_cpp_primitive("mset-int2", tc_subr_1,
        (PRIMITIVE (*)(...))  buildMSetInt);
        STk_add_new_cpp_primitive("set-int2", tc_subr_1,
        (PRIMITIVE (*)(...))  buildSetInt);
        STk_add_new_cpp_primitive("sequence-int2", tc_subr_1,
        (PRIMITIVE (*)(...))  buildSequenceInt);
        STk_add_new_cpp_primitive("Collection-int-member2", tc_subr_2,
        (PRIMITIVE (*)(...))  memberLinkIntCollection);
        STk_add_new_cpp_primitive("Collection-int-insert2!", tc_subr_2,
        (PRIMITIVE (*)(...))  insertLinkIntCollection);
        STk_add_new_cpp_primitive("Collection-int-append2!", tc_subr_2,
        (PRIMITIVE (*)(...))  appendLinkIntCollection);
        STk_add_new_cpp_primitive("Collection-int-remove2!", tc_subr_2,
        (PRIMITIVE (*)(...))  removeLinkIntCollection);
        STk_add_new_cpp_primitive("Collection-int-occurrences2", tc_subr_2,
        (PRIMITIVE (*)(...))  occurrencesLinkIntCollection);
        STk_add_new_cpp_primitive("Collection-int->list2", tc_subr_1,
        (PRIMITIVE (*)(...))  intCollection2STkList);

        addIntListMethod("mset-int", "mset-int1",  "mset-int2", LINK_OVL);
        addIntListMethod("set-int", "set-int1",  "set-int2", LINK_OVL);
        addIntListMethod("sequence-int", "sequence-int1",  "sequence-int2", 
							LINK_OVL);
        addOneArgMethod("list->mset-int",
                "<pair>",
                "mset-int2", LINK_OVL);
        addOneArgMethod("list->set-int",
                "<pair>",
                "set-int2", LINK_OVL);
        addOneArgMethod("list->sequence-int",
                "<pair>",
                "sequence-int2", LINK_OVL);

        addOneArgMethod("mset-int->list",
                Wrapper<_Collection_int__ >::name,
                "Collection-int->list2", LINK_OVL);

        addOneArgMethod("set-int->list",
                Wrapper<_Collection_int__ >::name,
                "Collection-int->list2", LINK_OVL);

        addOneArgMethod("sequence-int->list",
                Wrapper<_Collection_int__ >::name,
                "Collection-int->list2", LINK_OVL);

        addTwoArgMethod("member",
                "<integer>",
                Wrapper<_Collection_int__ >::name,
                "Collection-int-member2", LINK_OVL);
        addTwoArgMethod("insert!",
                "<integer>",
                Wrapper<_Collection_int__ >::name,
                "Collection-int-insert2!", LINK_OVL);
        addTwoArgMethod("append!",
                "<integer>",
                Wrapper<_Collection_int__ >::name,
                "Collection-int-append2!", LINK_NEW);
        addTwoArgMethod("remove!",
                "<integer>",
                Wrapper<_Collection_int__ >::name,
                "Collection-int-remove2!", LINK_NEW);
        addTwoArgMethod("occurrences",
                "<integer>",
                Wrapper<_Collection_int__ >::name,
                "Collection-int-occurrences2", LINK_NEW);
}
//genMethods "-g" "-t" "MSet<int*>" "-h" "Container" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/Container.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/Container.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>


typedef MSet<int*> _MSet_int__;
typedef Container<MSet<int*> > _Container_MSet_int___;

#define _Container_MSet_int___DATA(x) ((Container<MSet<int*> >*) (EXTDATA(x)))
#define _Container_MSet_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<MSet<int*> > >::type))
#define _Container_MSet_int___ISNT_DATA(x) (!IS_DATA(x))

#define _Container_MSet_int___CXX_DATA(x) (*(Container<MSet<int*> >*) (EXTDATA(VAL(x))))
#define _Container_MSet_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<MSet<int*> > >::type))
#define _Container_MSet_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Container_MSet_int___Methods() {}

//genMethods "-g" "-t" "Sequence<int*>" "-h" "Container" "-I" "LINK/basic/Sequence.h" "-I" "LINK/basic/Container.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Sequence.h>

#include <LINK/basic/Container.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>


typedef Sequence<int*> _Sequence_int__;
typedef Container<Sequence<int*> > _Container_Sequence_int___;

#define _Container_Sequence_int___DATA(x) ((Container<Sequence<int*> >*) (EXTDATA(x)))
#define _Container_Sequence_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Sequence<int*> > >::type))
#define _Container_Sequence_int___ISNT_DATA(x) (!_Container_Sequence_int___IS_DATA(x))

#define _Container_Sequence_int___CXX_DATA(x) (*(Container<Sequence<int*> >*) (EXTDATA(VAL(x))))
#define _Container_Sequence_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Sequence<int*> > >::type))
#define _Container_Sequence_int___CXX_ISNT_DATA(x) (!_Container_Sequence_int___CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Container_Sequence_int___Methods() {}
//genMethods "-g" "-t" "Set<char*>" "-h" "Container" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/Container.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/Container.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>


typedef Set<char*> _Set_char__;
typedef Container<Set<char*> > _Container_Set_char___;

#define _Container_Set_char___DATA(x) ((Container<Set<char*> >*) (EXTDATA(x)))
#define _Container_Set_char___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Set<char*> > >::type))
#define _Container_Set_char___ISNT_DATA(x) (!IS_DATA(x))

#define _Container_Set_char___CXX_DATA(x) (*(Container<Set<char*> >*) (EXTDATA(VAL(x))))
#define _Container_Set_char___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Set<char*> > >::type))
#define _Container_Set_char___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Container_Set_char___Methods() {}

//genMethods "-g" "-t" "Set<int*>" "-h" "Container" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/Container.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/Container.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>


typedef Set<int*> _Set_int__;
typedef Container<Set<int*> > _Container_Set_int___;

#define _Container_Set_int___DATA(x) ((Container<Set<int*> >*) (EXTDATA(x)))
#define _Container_Set_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Set<int*> > >::type))
#define _Container_Set_int___ISNT_DATA(x) (!IS_DATA(x))

#define _Container_Set_int___CXX_DATA(x) (*(Container<Set<int*> >*) (EXTDATA(VAL(x))))
#define _Container_Set_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Set<int*> > >::type))
#define _Container_Set_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Container_Set_int___Methods() {}

//genMethods "-t" "SubSet<int*>" "-h" "Container" "-I" "LINK/basic/Subset.h" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/Container.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Subset.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/Container.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>


typedef SubSet<int*> _SubSet_int__;
typedef Container<SubSet<int*> > _Container_SubSet_int___;

#define _Container_SubSet_int___DATA(x) ((Container<SubSet<int*> >*) (EXTDATA(x)))
#define _Container_SubSet_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<SubSet<int*> > >::type))
#define _Container_SubSet_int___ISNT_DATA(x) (!IS_DATA(x))

#define _Container_SubSet_int___CXX_DATA(x) (*(Container<SubSet<int*> >*) (EXTDATA(VAL(x))))
#define _Container_SubSet_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<SubSet<int*> > >::type))
#define _Container_SubSet_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Container_SubSet_int___Methods() {}

//genMethods "-g" "-t" "char*" "-h" "Container" "-I" "LINK/basic/Container.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Container.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>


typedef char* _char_;
typedef Container<char* > _Container_char__;

#define _Container_char__DATA(x) ((Container<char* >*) (EXTDATA(x)))
#define _Container_char__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<char* > >::type))
#define _Container_char__ISNT_DATA(x) (!IS_DATA(x))

#define _Container_char__CXX_DATA(x) (*(Container<char* >*) (EXTDATA(VAL(x))))
#define _Container_char__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<char* > >::type))
#define _Container_char__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Container_char__Methods() {}

//genMethods "-g" "-t" "int*" "-h" "Container" "-I" "LINK/basic/Container.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Container.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>


typedef int* _int_;
typedef Container<int* > _Container_int__;

#define _Container_int__DATA(x) ((Container<int* >*) (EXTDATA(x)))
#define _Container_int__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<int* > >::type))
#define _Container_int__ISNT_DATA(x) (!IS_DATA(x))

#define _Container_int__CXX_DATA(x) (*(Container<int* >*) (EXTDATA(VAL(x))))
#define _Container_int__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<int* > >::type))
#define _Container_int__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Container_int__Methods() {}

//genMethods "-g" "-t" "int*" "-h" "DList" "-I" "LINK/basic/DList.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/DList.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>


typedef int* _int_;
typedef DList<int* > _DList_int__;

#define _DList_int__DATA(x) ((DList<int* >*) (EXTDATA(x)))
#define _DList_int__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<DList<int* > >::type))
#define _DList_int__ISNT_DATA(x) (!IS_DATA(x))

#define _DList_int__CXX_DATA(x) (*(DList<int* >*) (EXTDATA(VAL(x))))
#define _DList_int__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<DList<int* > >::type))
#define _DList_int__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_DList_int__Methods() {}

//genMethods "-g" "-t" "MSet<int*>" "-h" "List" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/List.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef MSet<int*> _MSet_int__;
typedef List<MSet<int*> > _List_MSet_int___;

#define _List_MSet_int___DATA(x) ((List<MSet<int*> >*) (EXTDATA(x)))
#define _List_MSet_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<MSet<int*> > >::type))
#define _List_MSet_int___ISNT_DATA(x) (!IS_DATA(x))

#define _List_MSet_int___CXX_DATA(x) (*(List<MSet<int*> >*) (EXTDATA(VAL(x))))
#define _List_MSet_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<MSet<int*> > >::type))
#define _List_MSet_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_List_MSet_int___Methods() {}

//genMethods "-g" "-t" "Sequence<int*>" "-h" "List" "-I" "LINK/basic/Sequence.h" "-I" "LINK/basic/List.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Sequence.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Sequence<int*> _Sequence_int__;
typedef List<Sequence<int*> > _List_Sequence_int___;

#define _List_Sequence_int___DATA(x) ((List<Sequence<int*> >*) (EXTDATA(x)))
#define _List_Sequence_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Sequence<int*> > >::type))
#define _List_Sequence_int___ISNT_DATA(x) (!_List_Sequence_int___IS_DATA(x))

#define _List_Sequence_int___CXX_DATA(x) (*(List<Sequence<int*> >*) (EXTDATA(VAL(x))))
#define _List_Sequence_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Sequence<int*> > >::type))
#define _List_Sequence_int___CXX_ISNT_DATA(x) (!_List_Sequence_int___CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_List_Sequence_int___Methods() {}
//genMethods "-g" "-t" "Set<char*>" "-h" "List" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/List.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Set<char*> _Set_char__;
typedef List<Set<char*> > _List_Set_char___;

#define _List_Set_char___DATA(x) ((List<Set<char*> >*) (EXTDATA(x)))
#define _List_Set_char___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Set<char*> > >::type))
#define _List_Set_char___ISNT_DATA(x) (!IS_DATA(x))

#define _List_Set_char___CXX_DATA(x) (*(List<Set<char*> >*) (EXTDATA(VAL(x))))
#define _List_Set_char___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Set<char*> > >::type))
#define _List_Set_char___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_List_Set_char___Methods() {}

//genMethods "-g" "-t" "Set<int*>" "-h" "List" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/List.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Set<int*> _Set_int__;
typedef List<Set<int*> > _List_Set_int___;

#define _List_Set_int___DATA(x) ((List<Set<int*> >*) (EXTDATA(x)))
#define _List_Set_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Set<int*> > >::type))
#define _List_Set_int___ISNT_DATA(x) (!IS_DATA(x))

#define _List_Set_int___CXX_DATA(x) (*(List<Set<int*> >*) (EXTDATA(VAL(x))))
#define _List_Set_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Set<int*> > >::type))
#define _List_Set_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_List_Set_int___Methods() {}

//genMethods "-t" "SubSet<int*>" "-h" "List" "-I" "LINK/basic/Subset.h" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/List.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Subset.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef SubSet<int*> _SubSet_int__;
typedef List<SubSet<int*> > _List_SubSet_int___;

#define _List_SubSet_int___DATA(x) ((List<SubSet<int*> >*) (EXTDATA(x)))
#define _List_SubSet_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<SubSet<int*> > >::type))
#define _List_SubSet_int___ISNT_DATA(x) (!IS_DATA(x))

#define _List_SubSet_int___CXX_DATA(x) (*(List<SubSet<int*> >*) (EXTDATA(VAL(x))))
#define _List_SubSet_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<SubSet<int*> > >::type))
#define _List_SubSet_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_List_SubSet_int___Methods() {}

//genMethods "-g" "-t" "char*" "-h" "List" "-I" "LINK/basic/List.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef char* _char_;
typedef List<char* > _List_char__;

#define _List_char__DATA(x) ((List<char* >*) (EXTDATA(x)))
#define _List_char__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<char* > >::type))
#define _List_char__ISNT_DATA(x) (!IS_DATA(x))

#define _List_char__CXX_DATA(x) (*(List<char* >*) (EXTDATA(VAL(x))))
#define _List_char__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<char* > >::type))
#define _List_char__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_List_char__Methods() {}

//genMethods "-g" "-t" "int*" "-h" "List" "-I" "LINK/basic/List.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef int* _int_;
typedef List<int* > _List_int__;

#define _List_int__DATA(x) ((List<int* >*) (EXTDATA(x)))
#define _List_int__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<int* > >::type))
#define _List_int__ISNT_DATA(x) (!IS_DATA(x))
#define _List_int__CXX_DATA(x) (*(List<int* >*) (EXTDATA(VAL(x))))
#define _List_int__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<int* > >::type))
#define _List_int__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

static PRIMITIVE buildListInt(SCM l)
{
        SCM tmp, nl = NIL;
        SCM ne;
        SCM z;

        if (NNULLP(l)) {
                for (tmp=l; tmp != NIL; tmp = CDR(tmp))  {
                        ne = MakeIntCmd(CAR(tmp));
                        NEWCELL(z, tc_cons);
                        CAR(z) = ne;
                        CDR(z) = nl;
                        nl = z;
                }
                nl = STk_reverse(nl);
                return  ListWrapper<int*>::buildLinkList(nl);
        }
        return  NIL;
}

PRIMITIVE intList2STkList(SCM l)
{
        SCM z;

        if  (CXX_NTYPEP(l, Wrapper<List<int*> >::type))
                Err("typed-list-convert: wrong type of argument", l);
        List<int*> *lp = (List<int*>*) CLASSDATA(l);
        Iterator<int*> get_next(lp);
        int *e;
        if (get_next(e)) {
                SCM new_el = STk_makeinteger(*e);
                SCM tail, head;
                NEWCELL(tail, tc_cons);
                CAR(tail) = new_el;
                CDR(tail) = NIL;
                head = tail;
                SCM z;
                while (get_next(e)) {
                        SCM new_el  = STk_makeinteger(*e);
                        NEWCELL(z, tc_cons);
                        CAR(z) = new_el;
                        CDR(z) = NIL;
                        CDR(tail) = z;
                        tail = z;
                }
                return head;
        }
        return NIL;
}


// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_List_int__Methods() 
{
        STk_add_new_cpp_primitive("list-int2", tc_subr_1,
        (PRIMITIVE (*)(...))  buildListInt);
        STk_add_new_cpp_primitive("list-int->list2", tc_subr_1,
        (PRIMITIVE (*)(...))  intList2STkList);

        addIntListMethod("list-int", "list-int1", "list-int2", LINK_OVL);
        //addOneArgMethod("list->list-int",
        //        "<pair>",
        //        "list-int2", LINK_OVL);
        //addOneArgMethod("list-int->list",
        //        Wrapper<_List_int__ >::name,
        //        "list-int->list2", LINK_OVL);
}
//genMethods "-g" "-t" "MSet<int*>" "-h" "MSet" "-r" "Collection<MSet<int*> >" "-I" "LINK/basic/Set.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef MSet<int*> _MSet_int__;
typedef MSet<MSet<int*> > _MSet_MSet_int___;

#define _MSet_MSet_int___DATA(x) ((MSet<MSet<int*> >*) (EXTDATA(x)))
#define _MSet_MSet_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<MSet<int*> > >::type))
#define _MSet_MSet_int___ISNT_DATA(x) (!IS_DATA(x))

#define _MSet_MSet_int___CXX_DATA(x) (*(MSet<MSet<int*> >*) (EXTDATA(VAL(x))))
#define _MSet_MSet_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<MSet<int*> > >::type))
#define _MSet_MSet_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_MSet_MSet_int___Methods() {}

//genMethods "-g" "-t" "Sequence<int*>" "-h" "MSet" "-r" "Collection<Sequence<int*> >" "-I" "LINK/basic/Sequence.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Sequence<int*> _Sequence_int__;
typedef MSet<Sequence<int*> > _MSet_Sequence_int___;

#define _MSet_Sequence_int___DATA(x) ((MSet<Sequence<int*> >*) (EXTDATA(x)))
#define _MSet_Sequence_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Sequence<int*> > >::type))
#define _MSet_Sequence_int___ISNT_DATA(x) (!_MSet_Sequence_int___IS_DATA(x))

#define _MSet_Sequence_int___CXX_DATA(x) (*(MSet<Sequence<int*> >*) (EXTDATA(VAL(x))))
#define _MSet_Sequence_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Sequence<int*> > >::type))
#define _MSet_Sequence_int___CXX_ISNT_DATA(x) (!_MSet_Sequence_int___CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_MSet_Sequence_int___Methods() {}
//genMethods "-g" "-t" "Set<char*>" "-h" "MSet" "-r" "Collection<char*>" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/MSet.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/MSet.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Set<char*> _Set_char__;
typedef MSet<Set<char*> > _MSet_Set_char___;

#define _MSet_Set_char___DATA(x) ((MSet<Set<char*> >*) (EXTDATA(x)))
#define _MSet_Set_char___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Set<char*> > >::type))
#define _MSet_Set_char___ISNT_DATA(x) (!IS_DATA(x))

#define _MSet_Set_char___CXX_DATA(x) (*(MSet<Set<char*> >*) (EXTDATA(VAL(x))))
#define _MSet_Set_char___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Set<char*> > >::type))
#define _MSet_Set_char___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_MSet_Set_char___Methods() {}

//genMethods "-g" "-t" "Set<int*>" "-h" "MSet" "-r" "Collection<Set<int*> >" "-I" "LINK/basic/Set.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Set<int*> _Set_int__;
typedef MSet<Set<int*> > _MSet_Set_int___;

#define _MSet_Set_int___DATA(x) ((MSet<Set<int*> >*) (EXTDATA(x)))
#define _MSet_Set_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Set<int*> > >::type))
#define _MSet_Set_int___ISNT_DATA(x) (!IS_DATA(x))

#define _MSet_Set_int___CXX_DATA(x) (*(MSet<Set<int*> >*) (EXTDATA(VAL(x))))
#define _MSet_Set_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Set<int*> > >::type))
#define _MSet_Set_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_MSet_Set_int___Methods() {}

//genMethods "-t" "SubSet<int*>" "-h" "MSet" "-r" "Collection<SubSet<int*> >" "-I" "LINK/basic/Subset.h" "-I" "LINK/basic/Set.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Subset.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef SubSet<int*> _SubSet_int__;
typedef MSet<SubSet<int*> > _MSet_SubSet_int___;

#define _MSet_SubSet_int___DATA(x) ((MSet<SubSet<int*> >*) (EXTDATA(x)))
#define _MSet_SubSet_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<SubSet<int*> > >::type))
#define _MSet_SubSet_int___ISNT_DATA(x) (!IS_DATA(x))

#define _MSet_SubSet_int___CXX_DATA(x) (*(MSet<SubSet<int*> >*) (EXTDATA(VAL(x))))
#define _MSet_SubSet_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<SubSet<int*> > >::type))
#define _MSet_SubSet_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_MSet_SubSet_int___Methods() {}

//genMethods "-g" "-t" "char*" "-h" "MSet" "-r" "Collection<char*>" "-I" "LINK/basic/MSet.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/MSet.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef char* _char_;
typedef MSet<char* > _MSet_char__;

#define _MSet_char__DATA(x) ((MSet<char* >*) (EXTDATA(x)))
#define _MSet_char__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<char* > >::type))
#define _MSet_char__ISNT_DATA(x) (!IS_DATA(x))

#define _MSet_char__CXX_DATA(x) (*(MSet<char* >*) (EXTDATA(VAL(x))))
#define _MSet_char__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<char* > >::type))
#define _MSet_char__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_MSet_char__Methods() {}

//genMethods "-g" "-t" "int*" "-h" "MSet" "-r" "Collection<int*>" "-I" "LINK/basic/MSet.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/MSet.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef int* _int_;
typedef MSet<int* > _MSet_int__;

#define _MSet_int__DATA(x) ((MSet<int* >*) (EXTDATA(x)))
#define _MSet_int__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<int* > >::type))
#define _MSet_int__ISNT_DATA(x) (!IS_DATA(x))

#define _MSet_int__CXX_DATA(x) (*(MSet<int* >*) (EXTDATA(VAL(x))))
#define _MSet_int__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<int* > >::type))
#define _MSet_int__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_MSet_int__Methods() {}

//genMethods "-g" "-t" "MSet<int*>" "-h" "Sequence" "-r" "Collection<MSet<int*> >" "-I" "LINK/basic/Sequence.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef MSet<int*> _MSet_int__;
typedef Sequence<MSet<int*> > _Sequence_MSet_int___;

#define _Sequence_MSet_int___DATA(x) ((Sequence<MSet<int*> >*) (EXTDATA(x)))
#define _Sequence_MSet_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<MSet<int*> > >::type))
#define _Sequence_MSet_int___ISNT_DATA(x) (!IS_DATA(x))

#define _Sequence_MSet_int___CXX_DATA(x) (*(Sequence<MSet<int*> >*) (EXTDATA(VAL(x))))
#define _Sequence_MSet_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<MSet<int*> > >::type))
#define _Sequence_MSet_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Sequence_MSet_int___Methods() {}

//genMethods "-g" "-t" "Sequence<int*>" "-h" "Sequence" "-r" "Collection<Sequence<int*> >" "-I" "LINK/basic/Sequence.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Sequence<int*> _Sequence_int__;
typedef Sequence<Sequence<int*> > _Sequence_Sequence_int___;

#define _Sequence_Sequence_int___DATA(x) ((Sequence<Sequence<int*> >*) (EXTDATA(x)))
#define _Sequence_Sequence_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Sequence<int*> > >::type))
#define _Sequence_Sequence_int___ISNT_DATA(x) (!_Sequence_Sequence_int___IS_DATA(x))

#define _Sequence_Sequence_int___CXX_DATA(x) (*(Sequence<Sequence<int*> >*) (EXTDATA(VAL(x))))
#define _Sequence_Sequence_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Sequence<int*> > >::type))
#define _Sequence_Sequence_int___CXX_ISNT_DATA(x) (!_Sequence_Sequence_int___CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Sequence_Sequence_int___Methods() {}
//genMethods "-g" "-t" "Set<char*>" "-h" "Sequence" "-r" "Collection<char*>" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/Sequence.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Set<char*> _Set_char__;
typedef Sequence<Set<char*> > _Sequence_Set_char___;

#define _Sequence_Set_char___DATA(x) ((Sequence<Set<char*> >*) (EXTDATA(x)))
#define _Sequence_Set_char___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Set<char*> > >::type))
#define _Sequence_Set_char___ISNT_DATA(x) (!IS_DATA(x))

#define _Sequence_Set_char___CXX_DATA(x) (*(Sequence<Set<char*> >*) (EXTDATA(VAL(x))))
#define _Sequence_Set_char___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Set<char*> > >::type))
#define _Sequence_Set_char___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Sequence_Set_char___Methods() {}

//genMethods "-g" "-t" "Set<int*>" "-h" "Sequence" "-r" "Collection<Set<int*> >" "-I" "LINK/basic/Sequence.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Set<int*> _Set_int__;
typedef Sequence<Set<int*> > _Sequence_Set_int___;

#define _Sequence_Set_int___DATA(x) ((Sequence<Set<int*> >*) (EXTDATA(x)))
#define _Sequence_Set_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Set<int*> > >::type))
#define _Sequence_Set_int___ISNT_DATA(x) (!IS_DATA(x))

#define _Sequence_Set_int___CXX_DATA(x) (*(Sequence<Set<int*> >*) (EXTDATA(VAL(x))))
#define _Sequence_Set_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Set<int*> > >::type))
#define _Sequence_Set_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Sequence_Set_int___Methods() {}

//genMethods "-t" "SubSet<int*>" "-h" "Sequence" "-r" "Collection<SubSet<int*> >" "-I" "LINK/basic/Subset.h" "-I" "LINK/basic/Sequence.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Subset.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef SubSet<int*> _SubSet_int__;
typedef Sequence<SubSet<int*> > _Sequence_SubSet_int___;

#define _Sequence_SubSet_int___DATA(x) ((Sequence<SubSet<int*> >*) (EXTDATA(x)))
#define _Sequence_SubSet_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<SubSet<int*> > >::type))
#define _Sequence_SubSet_int___ISNT_DATA(x) (!IS_DATA(x))

#define _Sequence_SubSet_int___CXX_DATA(x) (*(Sequence<SubSet<int*> >*) (EXTDATA(VAL(x))))
#define _Sequence_SubSet_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<SubSet<int*> > >::type))
#define _Sequence_SubSet_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Sequence_SubSet_int___Methods() {}

//genMethods "-g" "-t" "char*" "-h" "Sequence" "-r" "Collection<char*>" "-I" "LINK/basic/Sequence.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef char* _char_;
typedef Sequence<char* > _Sequence_char__;

#define _Sequence_char__DATA(x) ((Sequence<char* >*) (EXTDATA(x)))
#define _Sequence_char__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<char* > >::type))
#define _Sequence_char__ISNT_DATA(x) (!IS_DATA(x))

#define _Sequence_char__CXX_DATA(x) (*(Sequence<char* >*) (EXTDATA(VAL(x))))
#define _Sequence_char__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<char* > >::type))
#define _Sequence_char__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Sequence_char__Methods() {}

//genMethods "-g" "-t" "int*" "-h" "Sequence" "-r" "Collection<int*>" "-I" "LINK/basic/Sequence.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef int* _int_;
typedef Sequence<int* > _Sequence_int__;

#define _Sequence_int__DATA(x) ((Sequence<int* >*) (EXTDATA(x)))
#define _Sequence_int__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<int* > >::type))
#define _Sequence_int__ISNT_DATA(x) (!IS_DATA(x))

#define _Sequence_int__CXX_DATA(x) (*(Sequence<int* >*) (EXTDATA(VAL(x))))
#define _Sequence_int__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<int* > >::type))
#define _Sequence_int__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Sequence_int__Methods() {}

//genMethods "-g" "-t" "MSet<int*>" "-h" "Set" "-r" "MSet<MSet<int*> >" "-I" "LINK/basic/Set.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef MSet<int*> _MSet_int__;
typedef Set<MSet<int*> > _Set_MSet_int___;

#define _Set_MSet_int___DATA(x) ((Set<MSet<int*> >*) (EXTDATA(x)))
#define _Set_MSet_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<MSet<int*> > >::type))
#define _Set_MSet_int___ISNT_DATA(x) (!IS_DATA(x))

#define _Set_MSet_int___CXX_DATA(x) (*(Set<MSet<int*> >*) (EXTDATA(VAL(x))))
#define _Set_MSet_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<MSet<int*> > >::type))
#define _Set_MSet_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Set_MSet_int___Methods() {}

//genMethods "-g" "-t" "Sequence<int*>" "-h" "Set" "-r" "MSet<Sequence<int*> >" "-I" "LINK/basic/Sequence.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Sequence<int*> _Sequence_int__;
typedef Set<Sequence<int*> > _Set_Sequence_int___;

#define _Set_Sequence_int___DATA(x) ((Set<Sequence<int*> >*) (EXTDATA(x)))
#define _Set_Sequence_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Sequence<int*> > >::type))
#define _Set_Sequence_int___ISNT_DATA(x) (!_Set_Sequence_int___IS_DATA(x))

#define _Set_Sequence_int___CXX_DATA(x) (*(Set<Sequence<int*> >*) (EXTDATA(VAL(x))))
#define _Set_Sequence_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Sequence<int*> > >::type))
#define _Set_Sequence_int___CXX_ISNT_DATA(x) (!_Set_Sequence_int___CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Set_Sequence_int___Methods() {}
//genMethods "-g" "-t" "Set<char*>" "-h" "Set" "-r" "MSet<char*>" "-I" "LINK/basic/Set.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Set<char*> _Set_char__;
typedef Set<Set<char*> > _Set_Set_char___;

#define _Set_Set_char___DATA(x) ((Set<Set<char*> >*) (EXTDATA(x)))
#define _Set_Set_char___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Set<char*> > >::type))
#define _Set_Set_char___ISNT_DATA(x) (!IS_DATA(x))

#define _Set_Set_char___CXX_DATA(x) (*(Set<Set<char*> >*) (EXTDATA(VAL(x))))
#define _Set_Set_char___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Set<char*> > >::type))
#define _Set_Set_char___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Set_Set_char___Methods() {}

//genMethods "-g" "-t" "Set<int*>" "-h" "Set" "-r" "MSet<Set<int*> >" "-I" "LINK/basic/Set.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Set<int*> _Set_int__;
typedef Set<Set<int*> > _Set_Set_int___;

#define _Set_Set_int___DATA(x) ((Set<Set<int*> >*) (EXTDATA(x)))
#define _Set_Set_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Set<int*> > >::type))
#define _Set_Set_int___ISNT_DATA(x) (!IS_DATA(x))

#define _Set_Set_int___CXX_DATA(x) (*(Set<Set<int*> >*) (EXTDATA(VAL(x))))
#define _Set_Set_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Set<int*> > >::type))
#define _Set_Set_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Set_Set_int___Methods() {}

//genMethods "-t" "SubSet<int*>" "-h" "Set" "-r" "MSet<SubSet<int*> >" "-I" "LINK/basic/Subset.h" "-I" "LINK/basic/Set.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Subset.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef SubSet<int*> _SubSet_int__;
typedef Set<SubSet<int*> > _Set_SubSet_int___;

#define _Set_SubSet_int___DATA(x) ((Set<SubSet<int*> >*) (EXTDATA(x)))
#define _Set_SubSet_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<SubSet<int*> > >::type))
#define _Set_SubSet_int___ISNT_DATA(x) (!IS_DATA(x))

#define _Set_SubSet_int___CXX_DATA(x) (*(Set<SubSet<int*> >*) (EXTDATA(VAL(x))))
#define _Set_SubSet_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<SubSet<int*> > >::type))
#define _Set_SubSet_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Set_SubSet_int___Methods() {}

//genMethods "-g" "-t" "char*" "-h" "Set" "-r" "MSet<char*>" "-I" "LINK/basic/Set.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef char* _char_;
typedef Set<char* > _Set_char__;

#define _Set_char__DATA(x) ((Set<char* >*) (EXTDATA(x)))
#define _Set_char__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<char* > >::type))
#define _Set_char__ISNT_DATA(x) (!IS_DATA(x))

#define _Set_char__CXX_DATA(x) (*(Set<char* >*) (EXTDATA(VAL(x))))
#define _Set_char__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<char* > >::type))
#define _Set_char__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Set_char__Methods() {}

//genMethods "-g" "-t" "int*" "-h" "Set" "-r" "MSet<int*>" "-I" "LINK/basic/Set.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef int* _int_;
typedef Set<int* > _Set_int__;

#define _Set_int__DATA(x) ((Set<int* >*) (EXTDATA(x)))
#define _Set_int__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<int* > >::type))
#define _Set_int__ISNT_DATA(x) (!IS_DATA(x))

#define _Set_int__CXX_DATA(x) (*(Set<int* >*) (EXTDATA(VAL(x))))
#define _Set_int__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<int* > >::type))
#define _Set_int__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Set_int__Methods() {}

//genMethods "-g" "-t" "char*" "-h" "SortedArray" "-r" "Array<char*>" "-I" "LINK/basic/Array.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Array.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ArrayWrapper.h>


typedef char* _char_;
typedef SortedArray<char* > _SortedArray_char__;

#define _SortedArray_char__DATA(x) ((SortedArray<char* >*) (EXTDATA(x)))
#define _SortedArray_char__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedArray<char* > >::type))
#define _SortedArray_char__ISNT_DATA(x) (!IS_DATA(x))

#define _SortedArray_char__CXX_DATA(x) (*(SortedArray<char* >*) (EXTDATA(VAL(x))))
#define _SortedArray_char__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedArray<char* > >::type))
#define _SortedArray_char__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedArray_char__Methods() {}

//genMethods "-g" "-t" "int*" "-h" "SortedArray" "-r" "Array<int*>" "-I" "LINK/basic/Array.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Array.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ArrayWrapper.h>


typedef int* _int_;
typedef SortedArray<int* > _SortedArray_int__;

#define _SortedArray_int__DATA(x) ((SortedArray<int* >*) (EXTDATA(x)))
#define _SortedArray_int__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedArray<int* > >::type))
#define _SortedArray_int__ISNT_DATA(x) (!IS_DATA(x))

#define _SortedArray_int__CXX_DATA(x) (*(SortedArray<int* >*) (EXTDATA(VAL(x))))
#define _SortedArray_int__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedArray<int* > >::type))
#define _SortedArray_int__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedArray_int__Methods() {}

//genMethods "-g" "-t" "MSet<int*>" "-h" "SortedList" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/List.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef MSet<int*> _MSet_int__;
typedef SortedList<MSet<int*> > _SortedList_MSet_int___;

#define _SortedList_MSet_int___DATA(x) ((SortedList<MSet<int*> >*) (EXTDATA(x)))
#define _SortedList_MSet_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<MSet<int*> > >::type))
#define _SortedList_MSet_int___ISNT_DATA(x) (!IS_DATA(x))

#define _SortedList_MSet_int___CXX_DATA(x) (*(SortedList<MSet<int*> >*) (EXTDATA(VAL(x))))
#define _SortedList_MSet_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<MSet<int*> > >::type))
#define _SortedList_MSet_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedList_MSet_int___Methods() {}

//genMethods "-g" "-t" "Sequence<int*>" "-h" "SortedList" "-I" "LINK/basic/Sequence.h" "-I" "LINK/basic/List.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Sequence.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Sequence<int*> _Sequence_int__;
typedef SortedList<Sequence<int*> > _SortedList_Sequence_int___;

#define _SortedList_Sequence_int___DATA(x) ((SortedList<Sequence<int*> >*) (EXTDATA(x)))
#define _SortedList_Sequence_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Sequence<int*> > >::type))
#define _SortedList_Sequence_int___ISNT_DATA(x) (!_SortedList_Sequence_int___IS_DATA(x))

#define _SortedList_Sequence_int___CXX_DATA(x) (*(SortedList<Sequence<int*> >*) (EXTDATA(VAL(x))))
#define _SortedList_Sequence_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Sequence<int*> > >::type))
#define _SortedList_Sequence_int___CXX_ISNT_DATA(x) (!_SortedList_Sequence_int___CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedList_Sequence_int___Methods() {}
//genMethods "-g" "-t" "Set<char*>" "-h" "SortedList" "-r" "List<char*>" "-I" "LINK/basic/List.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Set<char*> _Set_char__;
typedef SortedList<Set<char*> > _SortedList_Set_char___;

#define _SortedList_Set_char___DATA(x) ((SortedList<Set<char*> >*) (EXTDATA(x)))
#define _SortedList_Set_char___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Set<char*> > >::type))
#define _SortedList_Set_char___ISNT_DATA(x) (!IS_DATA(x))

#define _SortedList_Set_char___CXX_DATA(x) (*(SortedList<Set<char*> >*) (EXTDATA(VAL(x))))
#define _SortedList_Set_char___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Set<char*> > >::type))
#define _SortedList_Set_char___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedList_Set_char___Methods() {}

//genMethods "-g" "-t" "Set<int*>" "-h" "SortedList" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/List.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Set<int*> _Set_int__;
typedef SortedList<Set<int*> > _SortedList_Set_int___;

#define _SortedList_Set_int___DATA(x) ((SortedList<Set<int*> >*) (EXTDATA(x)))
#define _SortedList_Set_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Set<int*> > >::type))
#define _SortedList_Set_int___ISNT_DATA(x) (!IS_DATA(x))

#define _SortedList_Set_int___CXX_DATA(x) (*(SortedList<Set<int*> >*) (EXTDATA(VAL(x))))
#define _SortedList_Set_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Set<int*> > >::type))
#define _SortedList_Set_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedList_Set_int___Methods() {}

//genMethods "-t" "SubSet<int*>" "-h" "SortedList" "-I" "LINK/basic/Subset.h" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/List.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Subset.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef SubSet<int*> _SubSet_int__;
typedef SortedList<SubSet<int*> > _SortedList_SubSet_int___;

#define _SortedList_SubSet_int___DATA(x) ((SortedList<SubSet<int*> >*) (EXTDATA(x)))
#define _SortedList_SubSet_int___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<SubSet<int*> > >::type))
#define _SortedList_SubSet_int___ISNT_DATA(x) (!IS_DATA(x))

#define _SortedList_SubSet_int___CXX_DATA(x) (*(SortedList<SubSet<int*> >*) (EXTDATA(VAL(x))))
#define _SortedList_SubSet_int___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<SubSet<int*> > >::type))
#define _SortedList_SubSet_int___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedList_SubSet_int___Methods() {}

//genMethods "-g" "-t" "char*" "-h" "SortedList" "-r" "List<char*>" "-I" "LINK/basic/List.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef char* _char_;
typedef SortedList<char* > _SortedList_char__;

#define _SortedList_char__DATA(x) ((SortedList<char* >*) (EXTDATA(x)))
#define _SortedList_char__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<char* > >::type))
#define _SortedList_char__ISNT_DATA(x) (!IS_DATA(x))

#define _SortedList_char__CXX_DATA(x) (*(SortedList<char* >*) (EXTDATA(VAL(x))))
#define _SortedList_char__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<char* > >::type))
#define _SortedList_char__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedList_char__Methods() {}

//genMethods "-g" "-t" "int*" "-h" "SortedList" "-r" "List<int*>" "-I" "LINK/basic/List.h" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef int* _int_;
typedef SortedList<int* > _SortedList_int__;

#define _SortedList_int__DATA(x) ((SortedList<int* >*) (EXTDATA(x)))
#define _SortedList_int__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<int* > >::type))
#define _SortedList_int__ISNT_DATA(x) (!IS_DATA(x))

#define _SortedList_int__CXX_DATA(x) (*(SortedList<int* >*) (EXTDATA(VAL(x))))
#define _SortedList_int__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<int* > >::type))
#define _SortedList_int__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedList_int__Methods() {}

//genMethods "-g" "-t" "int*" "-h" "SubSet" "-I" "LINK/basic/Subset.h" "-y" "display_subset_int" "-d" "basic" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Subset.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_subset_int(SCM, SCM, int);

typedef int* _int_;
typedef SubSet<int* > _SubSet_int__;

#define _SubSet_int__DATA(x) ((SubSet<int* >*) (EXTDATA(x)))
#define _SubSet_int__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SubSet<int* > >::type))
#define _SubSet_int__ISNT_DATA(x) (!IS_DATA(x))

#define _SubSet_int__CXX_DATA(x) (*(SubSet<int* >*) (EXTDATA(VAL(x))))
#define _SubSet_int__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SubSet<int* > >::type))
#define _SubSet_int__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

#include<strstream.h>

void display_subset_int(SCM c, SCM port, int mode)
{
        ostrstream oss;
        if (_SubSet_int__DATA(c))
        	oss << *_SubSet_int__DATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}


// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SubSet_int__Methods() {}

//genMethods "-g" "-t" "char" "-d" "basic" "-y" "display_char" "-w" "free_char" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_char(SCM, SCM, int);
void free_char(SCM);

typedef char _char;

#define _charDATA(x) ((char*) (EXTDATA(x)))
#define _charIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<char >::type))
#define _charISNT_DATA(x) (!IS_DATA(x))

#define _charCXX_DATA(x) (*(char*) (EXTDATA(VAL(x))))
#define _charCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<char >::type))
#define _charCXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

#include<strstream.h>

void free_char(SCM p)
{
        if (!EXTSTATICP(p))
                Register<char>::deleteEntry(_charDATA(p));
}
void display_char(SCM c, SCM port, int mode)
{
        ostrstream oss;
        if (_charDATA(c))
        	oss << *_charDATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}




// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_charMethods() {}

//genMethods "-g" "-t" "char*" "-d" "basic" "-y" "display_charptr" "-w" "free_charptr" "-m" "mark_charptr" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_charptr(SCM, SCM, int);
void mark_charptr(SCM);
void free_charptr(SCM);

typedef char* _char_;

#define _char_DATA(x) ((char**) (EXTDATA(x)))
#define _char_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<char* >::type))
#define _char_ISNT_DATA(x) (!IS_DATA(x))

#define _char_CXX_DATA(x) (*(char**) (EXTDATA(VAL(x))))
#define _char_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<char* >::type))
#define _char_CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

#include<strstream.h>

void display_charptr(SCM c, SCM port, int mode)
{
        ostrstream oss;
        if (*_char_DATA(c))
        oss << **_char_DATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}

void mark_charptr(SCM p)
{
        //cout << "mark_charptr" << endl;
        Register<char>::markEntry(*_char_DATA(p));
}

void free_charptr(SCM p)
{
        //cout << "free_charptr" << endl;
        if (!EXTSTATICP(p)) {
                delete _char_DATA(p);
        }
}



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_char_Methods() {}

//genMethods "-g" "-t" "int" "-d" "basic" "-y" "display_int" "-w" "free_int" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_int(SCM, SCM, int);
void free_int(SCM);

typedef int _int;

#define _intDATA(x) ((int*) (EXTDATA(x)))
#define _intIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<int >::type))
#define _intISNT_DATA(x) (!IS_DATA(x))

#define _intCXX_DATA(x) (*(int*) (EXTDATA(VAL(x))))
#define _intCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<int >::type))
#define _intCXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

#include<iostream.h>
#include<strstream.h>

void free_int(SCM p)
{
	//cout << "free_int" << endl;
        if (!EXTSTATICP(p))
                Register<int>::deleteEntry(_intDATA(p));
}
void display_int(SCM c, SCM port, int mode)
{
        ostrstream oss;
        if (_intDATA(c))
        	oss << *_intDATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}


// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_intMethods() {}

//genMethods "-g" "-t" "int*" "-d" "basic" "-y" "display_intptr" "-w" "free_intptr" "-m" "mark_intptr" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_intptr(SCM, SCM, int);
void mark_intptr(SCM);
void free_intptr(SCM);

typedef int* _int_;

#define _int_DATA(x) ((int**) (EXTDATA(x)))
#define _int_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<int* >::type))
#define _int_ISNT_DATA(x) (!IS_DATA(x))

#define _int_CXX_DATA(x) (*(int**) (EXTDATA(VAL(x))))
#define _int_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<int* >::type))
#define _int_CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))


void display_intptr(SCM c, SCM port, int mode)
{
        ostrstream oss;
        if (*_int_DATA(c))
        oss << **_int_DATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}

void mark_intptr(SCM p)
{
        //cout << "mark_intptr" << endl;
        Register<int>::markEntry(*_int_DATA(p));
}

void free_intptr(SCM p)
{
        //cout << "free_intptr" << endl;
        if (!EXTSTATICP(p)) {
                delete _int_DATA(p);
        }
}

PRIMITIVE MakeIntCmd(SCM num)
{
        Tcl_HashEntry *p;
        SCM objptr;
        int *ap, **app;
        int not_found;

        if (NINTEGERP(num))
                Err("<integer> expected", num);
        ap = new int(INTEGER(num));
        //Register<int>::createEntry(ap);
        Register<int>::createEntry(Wrapper<int>::type,
                                       Wrapper<int>::name, ap);
        app = new int *(ap);
        return STk_make_CXXwrapper(Wrapper<int*>::type,
                        Wrapper<int*>::name, (void *) app, LINK_DYNAMIC);
}




// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_int_Methods() 
{
        STk_add_new_cpp_primitive("make-int", tc_subr_1,
                                        (PRIMITIVE (*)(...))MakeIntCmd);
}