///home/berryj/link/bin/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__;
static Array<char* > s__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) (!_Array_char__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) (!_Array_char__CXX_IS_DATA(x))



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

void genExtra_Array_char__Methods() {}
///home/berryj/link/bin/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_;
static Array<int > s__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) (!_Array_int_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) (!_Array_int_CXX_IS_DATA(x))



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

void genExtra_Array_int_Methods() {}
//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, (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" "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, (port));
        delete buffer;
}
// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below
void genExtra_charMethods() {}
///home/berryj/link/bin/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) (!_Collection_char__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) (!_Collection_char__CXX_IS_DATA(x))



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

void genExtra_Collection_char__Methods() {}
///home/berryj/link/bin/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) (!_Collection_int_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) (!_Collection_int_CXX_IS_DATA(x))



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

void genExtra_Collection_int_Methods() {}
///home/berryj/link/bin/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) (!_Collection_MSet_int__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) (!_Collection_MSet_int__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() {}
///home/berryj/link/bin/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() {}
///home/berryj/link/bin/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) (!_Collection_Set_char___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) (!_Collection_Set_char___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() {}
///home/berryj/link/bin/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) (!_Collection_Set_int__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) (!_Collection_Set_int__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() {}
///home/berryj/link/bin/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) (!_Collection_SubSet_int__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) (!_Collection_SubSet_int__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() {}
///home/berryj/link/bin/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) (!_Container_char__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) (!_Container_char__CXX_IS_DATA(x))



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

void genExtra_Container_char__Methods() {}
///home/berryj/link/bin/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) (!_Container_int_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) (!_Container_int_CXX_IS_DATA(x))



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

void genExtra_Container_int_Methods() {}
///home/berryj/link/bin/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) (!_Container_MSet_int__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) (!_Container_MSet_int__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() {}
///home/berryj/link/bin/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() {}
///home/berryj/link/bin/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) (!_Container_Set_char___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) (!_Container_Set_char___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() {}
///home/berryj/link/bin/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) (!_Container_Set_int__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) (!_Container_Set_int__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() {}
///home/berryj/link/bin/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) (!_Container_SubSet_int__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) (!_Container_SubSet_int__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() {}
///home/berryj/link/bin/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_;
static DList<int > s__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) (!_DList_int_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) (!_DList_int_CXX_IS_DATA(x))



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

void genExtra_DList_int_Methods() {}
///home/jon/link/bin/genMethods "-g" "-t" "double" "-d" "basic" "-y" "display_double" "-w" "free_double" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

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

void display_double(SCM, SCM, int);
void free_double(SCM);

typedef double _double;

#define _doubleDATA(x) ((double*) (EXTDATA(x)))
#define _doubleIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<double >::type))
#define _doubleISNT_DATA(x) (!_doubleIS_DATA(x))

#define _doubleCXX_DATA(x) (*(double*) (EXTDATA(VAL(x))))
#define _doubleCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<double >::type))
#define _doubleCXX_ISNT_DATA(x) (!_doubleCXX_IS_DATA(x))



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

void free_double(SCM p)
{
	//cout << "free_int" << endl;
        if (!EXTSTATICP(p))
                Register<double>::deleteEntry(_doubleDATA(p));
}
void display_double(SCM c, SCM port, int mode)
{
        ostrstream oss;
        if (_doubleDATA(c))
        	oss << *_doubleDATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, (port));
        delete buffer;
}
PRIMITIVE MakeDoubleCmd(SCM num)
{
        Tcl_HashEntry *p;
        SCM objptr;
        double *ap;
        int not_found;
        if (_doubleDATA(num))
                Err("<number> expected", num);
        ap = new double(*_doubleDATA(num));
        Register<double>::createEntry(Wrapper<double>::type,
                                       Wrapper<double>::name, ap);
        return STk_make_CXXwrapper(Wrapper<double>::type,
                        Wrapper<double>::name, (void *) ap, LINK_DYNAMIC);
}

void genExtra_doubleMethods() 
{
        STk_add_new_cpp_primitive("make-double", tc_subr_1,
                                        (PRIMITIVE (*)(...))MakeDoubleCmd);
}
//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, (port));
        delete buffer;
}
PRIMITIVE MakeIntCmd(SCM num)
{
        Tcl_HashEntry *p;
        SCM objptr;
        int *ap;
        int not_found;
        if (NINTEGERP(num))
                Err("<integer> expected", num);
        ap = new int(INTEGER(num));
        Register<int>::createEntry(Wrapper<int>::type,
                                       Wrapper<int>::name, ap);
        return STk_make_CXXwrapper(Wrapper<int>::type,
                        Wrapper<int>::name, (void *) ap, LINK_DYNAMIC);
}
static PRIMITIVE SeedRandomDoubleCmd(SCM n)
{
	if (NEXACTP(n)) Err("set-seed!: bad number", n);
	Link_setSeed(STk_integer_value_no_overflow(n));
	return UNDEFINED;
}
static PRIMITIVE RandomLongCmd(SCM n)
{
	if (NEXACTP(n)) Err("random-int: bad integer", n);
	long l = Link_randomLong();
	return STk_makeinteger(l % STk_integer_value_no_overflow(n));
}
static double round_it(double d, int places)
{
	double mult = pow(10.0, places);
	return floor(d * mult) / mult;
}
static PRIMITIVE RandomDoubleCmd()
{
	double d = Link_randomDouble0_1();
	return STk_makenumber(round_it(d, 3));
}
// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below
void genExtra_intMethods() 
{
        STk_add_new_cpp_primitive("set-seed!", tc_subr_1,
                                       (PRIMITIVE (*)(...))SeedRandomDoubleCmd);
        STk_add_new_cpp_primitive("random-int", tc_subr_1,
                                       (PRIMITIVE (*)(...))RandomLongCmd);
        STk_add_new_cpp_primitive("random-double", tc_subr_0,
                                        (PRIMITIVE (*)(...))RandomDoubleCmd);
        STk_add_new_cpp_primitive("make-int", tc_subr_1,
                                        (PRIMITIVE (*)(...))MakeIntCmd);
}
///home/berryj/link/bin/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__;
static List<char* > s__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) (!_List_char__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) (!_List_char__CXX_IS_DATA(x))



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

void genExtra_List_char__Methods() {}
///home/berryj/link/bin/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_;
static List<int > s__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) (!_List_int_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) (!_List_int_CXX_IS_DATA(x))



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

void genExtra_List_int_Methods() {}
///home/berryj/link/bin/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__;
static List<MSet<int> > s__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) (!_List_MSet_int__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) (!_List_MSet_int__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() {}
///home/berryj/link/bin/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__;
static List<Sequence<int> > s__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() {}
///home/berryj/link/bin/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___;
static List<Set<char*> > s__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) (!_List_Set_char___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) (!_List_Set_char___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() {}
///home/berryj/link/bin/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__;
static List<Set<int> > s__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) (!_List_Set_int__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) (!_List_Set_int__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() {}
///home/berryj/link/bin/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__;
static List<SubSet<int> > s__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) (!_List_SubSet_int__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) (!_List_SubSet_int__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() {}
///home/berryj/link/bin/genMethods "-g" "-t" "double" "-h" "Matrix" "-I" "LINK/basic/Matrix.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Matrix.h>

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


typedef double _double;
typedef Matrix<double > _Matrix_double_;
static Matrix<double > s__Matrix_double_;

#define _Matrix_double_DATA(x) ((Matrix<double >*) (EXTDATA(x)))
#define _Matrix_double_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Matrix<double > >::type))
#define _Matrix_double_ISNT_DATA(x) (!_Matrix_double_IS_DATA(x))

#define _Matrix_double_CXX_DATA(x) (*(Matrix<double >*) (EXTDATA(VAL(x))))
#define _Matrix_double_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Matrix<double > >::type))
#define _Matrix_double_CXX_ISNT_DATA(x) (!_Matrix_double_CXX_IS_DATA(x))



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

void genExtra_Matrix_double_Methods() {}
///home/jon/link/bin/genMethods "-g" "-t" "int" "-h" "Matrix" "-I" "LINK/basic/Matrix.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Matrix.h>

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


typedef int _int;
typedef Matrix<int > _Matrix_int_;
static Matrix<int > s__Matrix_int_;

#define _Matrix_int_DATA(x) ((Matrix<int >*) (EXTDATA(x)))
#define _Matrix_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<Matrix<int > >::type))
#define _Matrix_int_ISNT_DATA(x) (!_Matrix_int_IS_DATA(x))

#define _Matrix_int_CXX_DATA(x) (*(Matrix<int >*) (EXTDATA(VAL(x))))
#define _Matrix_int_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Matrix<int > >::type))
#define _Matrix_int_CXX_ISNT_DATA(x) (!_Matrix_int_CXX_IS_DATA(x))



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

void genExtra_Matrix_int_Methods() {}
///home/berryj/link/bin/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__;
static MSet<char* > s__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) (!_MSet_char__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) (!_MSet_char__CXX_IS_DATA(x))



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

void genExtra_MSet_char__Methods() {}
///home/berryj/link/bin/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_;
static MSet<int > s__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) (!_MSet_int_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) (!_MSet_int_CXX_IS_DATA(x))



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

void genExtra_MSet_int_Methods() {}
///home/berryj/link/bin/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__;
static MSet<MSet<int> > s__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) (!_MSet_MSet_int__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) (!_MSet_MSet_int__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() {}
///home/berryj/link/bin/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__;
static MSet<Sequence<int> > s__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() {}
///home/berryj/link/bin/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___;
static MSet<Set<char*> > s__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) (!_MSet_Set_char___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) (!_MSet_Set_char___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() {}
///home/berryj/link/bin/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__;
static MSet<Set<int> > s__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) (!_MSet_Set_int__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) (!_MSet_Set_int__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() {}
///home/berryj/link/bin/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__;
static MSet<SubSet<int> > s__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) (!_MSet_SubSet_int__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) (!_MSet_SubSet_int__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() {}
///home/berryj/link/bin/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__;
static Sequence<char* > s__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) (!_Sequence_char__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) (!_Sequence_char__CXX_IS_DATA(x))



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

void genExtra_Sequence_char__Methods() {}
///home/berryj/link/bin/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_;
static Sequence<int > s__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) (!_Sequence_int_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) (!_Sequence_int_CXX_IS_DATA(x))



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

void genExtra_Sequence_int_Methods() {}
///home/berryj/link/bin/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__;
static Sequence<MSet<int> > s__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) (!_Sequence_MSet_int__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) (!_Sequence_MSet_int__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() {}
///home/berryj/link/bin/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__;
static Sequence<Sequence<int> > s__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() {}
///home/berryj/link/bin/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___;
static Sequence<Set<char*> > s__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) (!_Sequence_Set_char___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) (!_Sequence_Set_char___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() {}
///home/berryj/link/bin/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__;
static Sequence<Set<int> > s__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) (!_Sequence_Set_int__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) (!_Sequence_Set_int__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() {}
///home/berryj/link/bin/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__;
static Sequence<SubSet<int> > s__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) (!_Sequence_SubSet_int__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) (!_Sequence_SubSet_int__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() {}
///home/berryj/link/bin/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__;
static Set<char* > s__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) (!_Set_char__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) (!_Set_char__CXX_IS_DATA(x))



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

void genExtra_Set_char__Methods() {}
///home/berryj/link/bin/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_;
static Set<int > s__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) (!_Set_int_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) (!_Set_int_CXX_IS_DATA(x))



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

void genExtra_Set_int_Methods() {}
///home/berryj/link/bin/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__;
static Set<MSet<int> > s__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) (!_Set_MSet_int__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) (!_Set_MSet_int__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() {}
///home/berryj/link/bin/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__;
static Set<Sequence<int> > s__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() {}
///home/berryj/link/bin/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___;
static Set<Set<char*> > s__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) (!_Set_Set_char___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) (!_Set_Set_char___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() {}
///home/berryj/link/bin/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__;
static Set<Set<int> > s__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) (!_Set_Set_int__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) (!_Set_Set_int__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() {}
///home/berryj/link/bin/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__;
static Set<SubSet<int> > s__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) (!_Set_SubSet_int__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) (!_Set_SubSet_int__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() {}
///home/berryj/link/bin/genMethods "-g" "-t" "char*" "-h" "SortedArray" "-r" "Array<char*>" "-I" "LINK/basic/SortedArray.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/SortedArray.h>

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


typedef char* _char_;
typedef SortedArray<char* > _SortedArray_char__;
static SortedArray<char* > s__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) (!_SortedArray_char__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) (!_SortedArray_char__CXX_IS_DATA(x))



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

void genExtra_SortedArray_char__Methods() {}
///home/berryj/link/bin/genMethods "-g" "-t" "int" "-h" "SortedArray" "-r" "Array<int>" "-I" "LINK/basic/SortedArray.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/SortedArray.h>

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


typedef int _int;
typedef SortedArray<int > _SortedArray_int_;
static SortedArray<int > s__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) (!_SortedArray_int_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) (!_SortedArray_int_CXX_IS_DATA(x))



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

void genExtra_SortedArray_int_Methods() {}
///home/berryj/link/bin/genMethods "-g" "-t" "char*" "-h" "SortedList" "-r" "List<char*>" "-I" "LINK/basic/SortedList.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/SortedList.h>

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


typedef char* _char_;
typedef SortedList<char* > _SortedList_char__;
static SortedList<char* > s__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) (!_SortedList_char__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) (!_SortedList_char__CXX_IS_DATA(x))



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

void genExtra_SortedList_char__Methods() {}
///home/berryj/link/bin/genMethods "-g" "-t" "int" "-h" "SortedList" "-r" "List<int>" "-I" "LINK/basic/SortedList.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/SortedList.h>

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


typedef int _int;
typedef SortedList<int > _SortedList_int_;
static SortedList<int > s__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) (!_SortedList_int_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) (!_SortedList_int_CXX_IS_DATA(x))



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

void genExtra_SortedList_int_Methods() {}
///home/berryj/link/bin/genMethods "-g" "-t" "MSet<int>" "-h" "SortedList" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/SortedList.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/SortedList.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__;
static SortedList<MSet<int> > s__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) (!_SortedList_MSet_int__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) (!_SortedList_MSet_int__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() {}
///home/berryj/link/bin/genMethods "-g" "-t" "Sequence<int>" "-h" "SortedList" "-I" "LINK/basic/Sequence.h" "-I" "LINK/basic/SortedList.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Sequence.h>

#include <LINK/basic/SortedList.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__;
static SortedList<Sequence<int> > s__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() {}
///home/berryj/link/bin/genMethods "-g" "-t" "Set<char*>" "-h" "SortedList" "-r" "List<char*>" "-I" "LINK/basic/SortedList.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/SortedList.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___;
static SortedList<Set<char*> > s__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) (!_SortedList_Set_char___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) (!_SortedList_Set_char___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() {}
///home/berryj/link/bin/genMethods "-g" "-t" "Set<int>" "-h" "SortedList" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/SortedList.h" "-d" "basic" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/SortedList.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__;
static SortedList<Set<int> > s__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) (!_SortedList_Set_int__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) (!_SortedList_Set_int__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() {}
///home/berryj/link/bin/genMethods "-t" "SubSet<int>" "-h" "SortedList" "-I" "LINK/basic/SubSet.h" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/SortedList.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/SortedList.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__;
static SortedList<SubSet<int> > s__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) (!_SortedList_SubSet_int__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) (!_SortedList_SubSet_int__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() {}
///home/berryj/link/bin/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_;
static SubSet<int > s__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) (!_SubSet_int_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) (!_SubSet_int_CXX_IS_DATA(x))


#include <strstream.h>

// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below
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, (port));
        delete buffer;
}

void genExtra_SubSet_int_Methods() {}
