///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))


PRIMITIVE STk_init__Array_char__()
{
	Wrapper<_Array_char__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Array_char__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ArrayWrapper<_char_>::displayTypedArray,
			(void (*)(SCM x))ArrayWrapper<_char_>::markTypedArray,
			(void (*)(SCM x))ArrayWrapper<_char_>::freeTypedArray);
	Tcl_InitHashTable(&Register<_Array_char__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Array_char__Methods(void);

PRIMITIVE STk_init_methods__Array_char__()
{
	STk_add_new_cpp_primitive("Vector-char-make", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::makeLinkArray);
	STk_add_new_cpp_primitive("Vector-char-make2", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::makeFilledLinkArray);
	STk_add_new_cpp_primitive("Vector-char-vector-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::refLinkArray);
	STk_add_new_cpp_primitive("Vector-char?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::linkArrayP);
	STk_add_new_cpp_primitive("vector-char", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::buildLinkArray);
	STk_add_new_cpp_primitive("Vector-char-vector-fill!", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::fillLinkArray);
	STk_add_new_cpp_primitive("Vector-char-vector-copy", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::copyLinkArray);
	STk_add_new_cpp_primitive("Vector-char-vector-set!", tc_subr_3, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::setLinkArray);
	STk_add_new_cpp_primitive("Vector-char-vector-length", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::lengthLinkArray);
	STk_add_new_cpp_primitive("Vector-char-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::eqvLinkArray);
	STk_add_new_cpp_primitive("Vector-char-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::lthLinkArray);
	STk_add_new_cpp_primitive("Vector-char-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::leLinkArray);
	STk_add_new_cpp_primitive("Vector-char->", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::grLinkArray);
	STk_add_new_cpp_primitive("Vector-char->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::geLinkArray);
	STk_add_new_cpp_primitive("Vector-char-vector-resize", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::resizeLinkArray);
	STk_add_new_cpp_primitive("list->Vector-char", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::stkList2LinkArray);
	STk_add_new_cpp_primitive("Vector-char->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_char_>::linkArray2STkList);

	addOneArgMethod("vector-copy",
		Wrapper<_Array_char__ >::name, 
		"Vector-char-vector-copy", LINK_OVL);
	addOneArgMethod("vector->list",
		Wrapper<_Array_char__ >::name, 
		"Vector-char-vector->list", LINK_OVL);
	addOneArgMethod("vector-length",
		Wrapper<_Array_char__ >::name, 
		"Vector-char-vector-length", LINK_OVL);
	addTwoArgMethod("vector-ref",
		Wrapper<_Array_char__ >::name, 
		"<integer>",
		"Vector-char-vector-ref", LINK_OVL);
	addTwoArgMethod("vector-fill!",
		Wrapper<_Array_char__ >::name, 
		Wrapper<_char_ >::name, 
		"Vector-char-vector-fill!", LINK_OVL);
	addTwoArgMethod("vector-resize",
		Wrapper<_Array_char__ >::name, 
		"<integer>",
		"Vector-char-vector-resize", LINK_OVL);
	addThreeArgMethod("vector-set!",
		Wrapper<_Array_char__ >::name, 
		"<integer>",
		Wrapper<_char_ >::name, 
		"Vector-char-vector-set!", LINK_OVL);
	addTwoArgMethod("eqv?",
		Wrapper<_Array_char__ >::name, 
		Wrapper<_Array_char__ >::name, 
		"Vector-char-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Array_char__ >::name, 
		"Vector-char-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Array_char__ >::name, 
		"Vector-char-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Array_char__ >::name, 
		"Vector-char->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Array_char__ >::name, 
		"Vector-char->=", LINK_OVL);
	genExtra_Array_char__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Array_int_()
{
	Wrapper<_Array_int_>::type = STk_new_CXXwrapper_id(
			Wrapper<_Array_int_>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ArrayWrapper<_int>::displayTypedArray,
			(void (*)(SCM x))ArrayWrapper<_int>::markTypedArray,
			(void (*)(SCM x))ArrayWrapper<_int>::freeTypedArray);
	Tcl_InitHashTable(&Register<_Array_int_>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Array_int_Methods(void);

PRIMITIVE STk_init_methods__Array_int_()
{
	STk_add_new_cpp_primitive("Vector-int-make", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::makeLinkArray);
	STk_add_new_cpp_primitive("Vector-int-make2", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::makeFilledLinkArray);
	STk_add_new_cpp_primitive("Vector-int-vector-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::refLinkArray);
	STk_add_new_cpp_primitive("Vector-int?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::linkArrayP);
	STk_add_new_cpp_primitive("vector-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::buildLinkArray);
	STk_add_new_cpp_primitive("Vector-int-vector-fill!", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::fillLinkArray);
	STk_add_new_cpp_primitive("Vector-int-vector-copy", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::copyLinkArray);
	STk_add_new_cpp_primitive("Vector-int-vector-set!", tc_subr_3, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::setLinkArray);
	STk_add_new_cpp_primitive("Vector-int-vector-length", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::lengthLinkArray);
	STk_add_new_cpp_primitive("Vector-int-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::eqvLinkArray);
	STk_add_new_cpp_primitive("Vector-int-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::lthLinkArray);
	STk_add_new_cpp_primitive("Vector-int-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::leLinkArray);
	STk_add_new_cpp_primitive("Vector-int->", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::grLinkArray);
	STk_add_new_cpp_primitive("Vector-int->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::geLinkArray);
	STk_add_new_cpp_primitive("Vector-int-vector-resize", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::resizeLinkArray);
	STk_add_new_cpp_primitive("list->Vector-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::stkList2LinkArray);
	STk_add_new_cpp_primitive("Vector-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_int>::linkArray2STkList);

	addOneArgMethod("vector-copy",
		Wrapper<_Array_int_ >::name, 
		"Vector-int-vector-copy", LINK_OVL);
	addOneArgMethod("vector->list",
		Wrapper<_Array_int_ >::name, 
		"Vector-int-vector->list", LINK_OVL);
	addOneArgMethod("vector-length",
		Wrapper<_Array_int_ >::name, 
		"Vector-int-vector-length", LINK_OVL);
	addTwoArgMethod("vector-ref",
		Wrapper<_Array_int_ >::name, 
		"<integer>",
		"Vector-int-vector-ref", LINK_OVL);
	addTwoArgMethod("vector-fill!",
		Wrapper<_Array_int_ >::name, 
		Wrapper<_int >::name, 
		"Vector-int-vector-fill!", LINK_OVL);
	addTwoArgMethod("vector-resize",
		Wrapper<_Array_int_ >::name, 
		"<integer>",
		"Vector-int-vector-resize", LINK_OVL);
	addThreeArgMethod("vector-set!",
		Wrapper<_Array_int_ >::name, 
		"<integer>",
		Wrapper<_int >::name, 
		"Vector-int-vector-set!", LINK_OVL);
	addTwoArgMethod("eqv?",
		Wrapper<_Array_int_ >::name, 
		Wrapper<_Array_int_ >::name, 
		"Vector-int-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Array_int_ >::name, 
		"Vector-int-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Array_int_ >::name, 
		"Vector-int-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Array_int_ >::name, 
		"Vector-int->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Array_int_ >::name, 
		"Vector-int->=", LINK_OVL);
	genExtra_Array_int_Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Collection_MSet_int__()
{
	Wrapper<_Collection_MSet_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_MSet_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_MSet_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_MSet_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_MSet_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_MSet_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_MSet_int__Methods(void);

PRIMITIVE STk_init_methods__Collection_MSet_int__()
{
	STk_add_new_cpp_primitive("collection-MSet-int?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::collectionP);
	STk_add_new_cpp_primitive("mset-MSet-int1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::buildMSet);
	STk_add_new_cpp_primitive("set-MSet-int1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::buildSet);
	STk_add_new_cpp_primitive("sequence-MSet-int1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::buildSequence);
	STk_add_new_cpp_primitive("Collection-MSet-int-sorted?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::sortedLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-size", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::sizeLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-null?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::nullLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::eqvLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::lthLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::leLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int->", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::grLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::geLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-member", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::memberLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-clear!", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::clearLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-insert!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::insertLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-append!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::appendLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-remove!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::removeLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-occurrences", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::occurrencesLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::refLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-rank", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::rankLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-+", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::unionLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-^", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::intersectionLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int--", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::differenceLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::subsetLinkCollection);
	STk_add_new_cpp_primitive("Collection-MSet-int-proper-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::properSubsetLinkCollection);
	STk_add_new_cpp_primitive("list->mset-MSet-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::stkList2LinkMSet);
	STk_add_new_cpp_primitive("list->set-MSet-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::stkList2LinkSet);
	STk_add_new_cpp_primitive("list->sequence-MSet-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::stkList2LinkSequence);
	STk_add_new_cpp_primitive("mset-MSet-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::collection2STkList);
	STk_add_new_cpp_primitive("set-MSet-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::collection2STkList);
	STk_add_new_cpp_primitive("sequence-MSet-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::collection2STkList);
	STk_add_new_cpp_primitive("mset-MSet-int->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::collection2STkString);
	STk_add_new_cpp_primitive("set-MSet-int->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::collection2STkString);
	STk_add_new_cpp_primitive("sequence-MSet-int->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_MSet_int_>::collection2STkString);

	addListMethod("mset-MSet-int",
		"mset-MSet-int1", LINK_NEW);
	addListMethod("set-MSet-int",
		"set-MSet-int1", LINK_NEW);
	addListMethod("sequence-MSet-int",
		"sequence-MSet-int1", LINK_NEW);
	addOneArgMethod("null?",
		Wrapper<_Collection_MSet_int__ >::name, 
		"Collection-MSet-int-null?", LINK_OVL);
	addOneArgMethod("size",
		Wrapper<_Collection_MSet_int__ >::name, 
		"Collection-MSet-int-size", LINK_NEW);
	addTwoArgMethod("eqv?",
		Wrapper<_Collection_MSet_int__ >::name, 
		Wrapper<_Collection_MSet_int__ >::name, 
		"Collection-MSet-int-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Collection_MSet_int__ >::name, 
		"Collection-MSet-int-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Collection_MSet_int__ >::name, 
		"Collection-MSet-int-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Collection_MSet_int__ >::name, 
		"Collection-MSet-int->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Collection_MSet_int__ >::name, 
		"Collection-MSet-int->=", LINK_OVL);
	addTwoArgMethod("member",
		Wrapper<_MSet_int_ >::name, 
		Wrapper<_Collection_MSet_int__ >::name, 
		"Collection-MSet-int-member", LINK_OVL);
	addTwoArgMethod("ref",
		Wrapper<_Collection_MSet_int__ >::name, 
		"<integer>",
		"Collection-MSet-int-ref", LINK_NEW);
	addOneArgMethod("clear!",
		Wrapper<_Collection_MSet_int__ >::name, 
		"Collection-MSet-int-clear!", LINK_NEW);
	addTwoArgMethod("insert!",
		Wrapper<_MSet_int_ >::name, 
		Wrapper<_Collection_MSet_int__ >::name, 
		"Collection-MSet-int-insert!", LINK_NEW);
	addTwoArgMethod("append!",
		Wrapper<_MSet_int_ >::name, 
		Wrapper<_Collection_MSet_int__ >::name, 
		"Collection-MSet-int-append!", LINK_NEW);
	addTwoArgMethod("remove!",
		Wrapper<_MSet_int_ >::name, 
		Wrapper<_Collection_MSet_int__ >::name, 
		"Collection-MSet-int-remove!", LINK_NEW);
	addArbMethod("+",
		Wrapper<_Collection_MSet_int__ >::name, 
		"Collection-MSet-int-+", LINK_OVL);
	addArbMethod("^",
		Wrapper<_Collection_MSet_int__ >::name, 
		"Collection-MSet-int-^", LINK_NEW);
	addArbMethod("-",
		Wrapper<_Collection_MSet_int__ >::name, 
		"Collection-MSet-int--", LINK_OVL);
	genExtra_Collection_MSet_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Collection_Sequence_int__()
{
	Wrapper<_Collection_Sequence_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_Sequence_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Sequence_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_Sequence_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_Sequence_int__Methods(void);

PRIMITIVE STk_init_methods__Collection_Sequence_int__()
{
	STk_add_new_cpp_primitive("collection-Sequence-int?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::collectionP);
	STk_add_new_cpp_primitive("mset-Sequence-int1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::buildMSet);
	STk_add_new_cpp_primitive("set-Sequence-int1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::buildSet);
	STk_add_new_cpp_primitive("sequence-Sequence-int1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::buildSequence);
	STk_add_new_cpp_primitive("Collection-Sequence-int-sorted?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::sortedLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-size", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::sizeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-null?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::nullLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::eqvLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::lthLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::leLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int->", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::grLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::geLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-member", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::memberLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-clear!", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::clearLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-insert!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::insertLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-append!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::appendLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-remove!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::removeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-occurrences", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::occurrencesLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::refLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-rank", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::rankLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-+", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::unionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-^", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::intersectionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int--", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::differenceLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::subsetLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-int-proper-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::properSubsetLinkCollection);
	STk_add_new_cpp_primitive("list->mset-Sequence-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::stkList2LinkMSet);
	STk_add_new_cpp_primitive("list->set-Sequence-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::stkList2LinkSet);
	STk_add_new_cpp_primitive("list->sequence-Sequence-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::stkList2LinkSequence);
	STk_add_new_cpp_primitive("mset-Sequence-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::collection2STkList);
	STk_add_new_cpp_primitive("set-Sequence-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::collection2STkList);
	STk_add_new_cpp_primitive("sequence-Sequence-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::collection2STkList);
	STk_add_new_cpp_primitive("mset-Sequence-int->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::collection2STkString);
	STk_add_new_cpp_primitive("set-Sequence-int->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::collection2STkString);
	STk_add_new_cpp_primitive("sequence-Sequence-int->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_int_>::collection2STkString);
	STk_add_new_cpp_primitive("Collection-Sequence-int-cartesian-product", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<int >::cartesianProduct);
	STk_add_new_cpp_primitive("Collection-Sequence-int-choose", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<int >::choose);
	STk_add_new_cpp_primitive("Collection-Sequence-int-power-set", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<int >::powerSet);
	STk_add_new_cpp_primitive("Collection-Sequence-int-permutations", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<int >::permutations);
	STk_add_new_cpp_primitive("Collection-Sequence-int-permutation", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<int >::permutation);
	STk_add_new_cpp_primitive("Collection-Sequence-int-permutation-rank", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<int >::rank);

	addListMethod("mset-Sequence-int",
		"mset-Sequence-int1", LINK_NEW);
	addListMethod("set-Sequence-int",
		"set-Sequence-int1", LINK_NEW);
	addListMethod("sequence-Sequence-int",
		"sequence-Sequence-int1", LINK_NEW);
	addOneArgMethod("null?",
		Wrapper<_Collection_Sequence_int__ >::name, 
		"Collection-Sequence-int-null?", LINK_OVL);
	addOneArgMethod("size",
		Wrapper<_Collection_Sequence_int__ >::name, 
		"Collection-Sequence-int-size", LINK_NEW);
	addTwoArgMethod("eqv?",
		Wrapper<_Collection_Sequence_int__ >::name, 
		Wrapper<_Collection_Sequence_int__ >::name, 
		"Collection-Sequence-int-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Collection_Sequence_int__ >::name, 
		"Collection-Sequence-int-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Collection_Sequence_int__ >::name, 
		"Collection-Sequence-int-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Collection_Sequence_int__ >::name, 
		"Collection-Sequence-int->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Collection_Sequence_int__ >::name, 
		"Collection-Sequence-int->=", LINK_OVL);
	addTwoArgMethod("member",
		Wrapper<_Sequence_int_ >::name, 
		Wrapper<_Collection_Sequence_int__ >::name, 
		"Collection-Sequence-int-member", LINK_OVL);
	addTwoArgMethod("ref",
		Wrapper<_Collection_Sequence_int__ >::name, 
		"<integer>",
		"Collection-Sequence-int-ref", LINK_NEW);
	addOneArgMethod("clear!",
		Wrapper<_Collection_Sequence_int__ >::name, 
		"Collection-Sequence-int-clear!", LINK_NEW);
	addTwoArgMethod("insert!",
		Wrapper<_Sequence_int_ >::name, 
		Wrapper<_Collection_Sequence_int__ >::name, 
		"Collection-Sequence-int-insert!", LINK_NEW);
	addTwoArgMethod("append!",
		Wrapper<_Sequence_int_ >::name, 
		Wrapper<_Collection_Sequence_int__ >::name, 
		"Collection-Sequence-int-append!", LINK_NEW);
	addTwoArgMethod("remove!",
		Wrapper<_Sequence_int_ >::name, 
		Wrapper<_Collection_Sequence_int__ >::name, 
		"Collection-Sequence-int-remove!", LINK_NEW);
	addArbMethod("+",
		Wrapper<_Collection_Sequence_int__ >::name, 
		"Collection-Sequence-int-+", LINK_OVL);
	addArbMethod("^",
		Wrapper<_Collection_Sequence_int__ >::name, 
		"Collection-Sequence-int-^", LINK_NEW);
	addArbMethod("-",
		Wrapper<_Collection_Sequence_int__ >::name, 
		"Collection-Sequence-int--", LINK_OVL);
	addTwoArgMethod("cartesian-product",
		Wrapper<_Sequence_int_ >::name, 
		Wrapper<_Sequence_int_ >::name, 
		"Collection-Sequence-int-cartesian-product", LINK_NEW);
	addTwoArgMethod("choose",
		Wrapper<_Sequence_int_ >::name, 
		"<integer>",
		"Collection-Sequence-int-choose", LINK_NEW);
	addOneArgMethod("power-set",
		Wrapper<_Sequence_int_ >::name, 
		"Collection-Sequence-int-power-set", LINK_NEW);
	addOneArgMethod("permutations",
		Wrapper<_Sequence_int_ >::name, 
		"Collection-Sequence-int-permutations", LINK_NEW);
	addTwoArgMethod("permutation",
		Wrapper<_Sequence_int_ >::name, 
		"<integer>",
		"Collection-Sequence-int-permutation", LINK_NEW);
	addOneArgMethod("permutation-rank",
		Wrapper<_Sequence_int_ >::name, 
		"Collection-Sequence-int-permutation-rank", LINK_NEW);
	genExtra_Collection_Sequence_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Collection_Set_char___()
{
	Wrapper<_Collection_Set_char___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_Set_char___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_char__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_char__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_char__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_Set_char___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_Set_char___Methods(void);

PRIMITIVE STk_init_methods__Collection_Set_char___()
{
	STk_add_new_cpp_primitive("collection-Set-char?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::collectionP);
	STk_add_new_cpp_primitive("mset-Set-char1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::buildMSet);
	STk_add_new_cpp_primitive("set-Set-char1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::buildSet);
	STk_add_new_cpp_primitive("sequence-Set-char1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::buildSequence);
	STk_add_new_cpp_primitive("Collection-Set-char-sorted?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::sortedLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-size", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::sizeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-null?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::nullLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::eqvLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::lthLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::leLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char->", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::grLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::geLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-member", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::memberLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-clear!", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::clearLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-insert!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::insertLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-append!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::appendLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-remove!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::removeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-occurrences", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::occurrencesLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::refLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-rank", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::rankLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-+", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::unionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-^", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::intersectionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char--", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::differenceLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::subsetLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-char-proper-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::properSubsetLinkCollection);
	STk_add_new_cpp_primitive("list->mset-Set-char", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::stkList2LinkMSet);
	STk_add_new_cpp_primitive("list->set-Set-char", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::stkList2LinkSet);
	STk_add_new_cpp_primitive("list->sequence-Set-char", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::stkList2LinkSequence);
	STk_add_new_cpp_primitive("mset-Set-char->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::collection2STkList);
	STk_add_new_cpp_primitive("set-Set-char->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::collection2STkList);
	STk_add_new_cpp_primitive("sequence-Set-char->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::collection2STkList);
	STk_add_new_cpp_primitive("mset-Set-char->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::collection2STkString);
	STk_add_new_cpp_primitive("set-Set-char->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::collection2STkString);
	STk_add_new_cpp_primitive("sequence-Set-char->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_char__>::collection2STkString);

	addListMethod("mset-Set-char",
		"mset-Set-char1", LINK_NEW);
	addListMethod("set-Set-char",
		"set-Set-char1", LINK_NEW);
	addListMethod("sequence-Set-char",
		"sequence-Set-char1", LINK_NEW);
	addOneArgMethod("null?",
		Wrapper<_Collection_Set_char___ >::name, 
		"Collection-Set-char-null?", LINK_OVL);
	addOneArgMethod("size",
		Wrapper<_Collection_Set_char___ >::name, 
		"Collection-Set-char-size", LINK_NEW);
	addTwoArgMethod("eqv?",
		Wrapper<_Collection_Set_char___ >::name, 
		Wrapper<_Collection_Set_char___ >::name, 
		"Collection-Set-char-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Collection_Set_char___ >::name, 
		"Collection-Set-char-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Collection_Set_char___ >::name, 
		"Collection-Set-char-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Collection_Set_char___ >::name, 
		"Collection-Set-char->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Collection_Set_char___ >::name, 
		"Collection-Set-char->=", LINK_OVL);
	addTwoArgMethod("member",
		Wrapper<_Set_char__ >::name, 
		Wrapper<_Collection_Set_char___ >::name, 
		"Collection-Set-char-member", LINK_OVL);
	addTwoArgMethod("ref",
		Wrapper<_Collection_Set_char___ >::name, 
		"<integer>",
		"Collection-Set-char-ref", LINK_NEW);
	addOneArgMethod("clear!",
		Wrapper<_Collection_Set_char___ >::name, 
		"Collection-Set-char-clear!", LINK_NEW);
	addTwoArgMethod("insert!",
		Wrapper<_Set_char__ >::name, 
		Wrapper<_Collection_Set_char___ >::name, 
		"Collection-Set-char-insert!", LINK_NEW);
	addTwoArgMethod("append!",
		Wrapper<_Set_char__ >::name, 
		Wrapper<_Collection_Set_char___ >::name, 
		"Collection-Set-char-append!", LINK_NEW);
	addTwoArgMethod("remove!",
		Wrapper<_Set_char__ >::name, 
		Wrapper<_Collection_Set_char___ >::name, 
		"Collection-Set-char-remove!", LINK_NEW);
	addArbMethod("+",
		Wrapper<_Collection_Set_char___ >::name, 
		"Collection-Set-char-+", LINK_OVL);
	addArbMethod("^",
		Wrapper<_Collection_Set_char___ >::name, 
		"Collection-Set-char-^", LINK_NEW);
	addArbMethod("-",
		Wrapper<_Collection_Set_char___ >::name, 
		"Collection-Set-char--", LINK_OVL);
	genExtra_Collection_Set_char___Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Collection_Set_int__()
{
	Wrapper<_Collection_Set_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_Set_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_Set_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_Set_int__Methods(void);

PRIMITIVE STk_init_methods__Collection_Set_int__()
{
	STk_add_new_cpp_primitive("collection-Set-int?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::collectionP);
	STk_add_new_cpp_primitive("mset-Set-int1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::buildMSet);
	STk_add_new_cpp_primitive("set-Set-int1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::buildSet);
	STk_add_new_cpp_primitive("sequence-Set-int1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::buildSequence);
	STk_add_new_cpp_primitive("Collection-Set-int-sorted?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::sortedLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-size", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::sizeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-null?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::nullLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::eqvLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::lthLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::leLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int->", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::grLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::geLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-member", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::memberLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-clear!", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::clearLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-insert!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::insertLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-append!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::appendLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-remove!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::removeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-occurrences", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::occurrencesLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::refLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-rank", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::rankLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-+", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::unionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-^", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::intersectionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int--", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::differenceLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::subsetLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-int-proper-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::properSubsetLinkCollection);
	STk_add_new_cpp_primitive("list->mset-Set-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::stkList2LinkMSet);
	STk_add_new_cpp_primitive("list->set-Set-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::stkList2LinkSet);
	STk_add_new_cpp_primitive("list->sequence-Set-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::stkList2LinkSequence);
	STk_add_new_cpp_primitive("mset-Set-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::collection2STkList);
	STk_add_new_cpp_primitive("set-Set-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::collection2STkList);
	STk_add_new_cpp_primitive("sequence-Set-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::collection2STkList);
	STk_add_new_cpp_primitive("mset-Set-int->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::collection2STkString);
	STk_add_new_cpp_primitive("set-Set-int->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::collection2STkString);
	STk_add_new_cpp_primitive("sequence-Set-int->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_int_>::collection2STkString);
	STk_add_new_cpp_primitive("Collection-Set-int-cartesian-product", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<int >::cartesianProduct);
	STk_add_new_cpp_primitive("Collection-Set-int-choose", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<int >::choose);
	STk_add_new_cpp_primitive("Collection-Set-int-power-set", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<int >::powerSet);
	STk_add_new_cpp_primitive("Collection-Set-int-permutations", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<int >::permutations);
	STk_add_new_cpp_primitive("Collection-Set-int-permutation", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<int >::permutation);
	STk_add_new_cpp_primitive("Collection-Set-int-permutation-rank", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<int >::rank);

	addListMethod("mset-Set-int",
		"mset-Set-int1", LINK_NEW);
	addListMethod("set-Set-int",
		"set-Set-int1", LINK_NEW);
	addListMethod("sequence-Set-int",
		"sequence-Set-int1", LINK_NEW);
	addOneArgMethod("null?",
		Wrapper<_Collection_Set_int__ >::name, 
		"Collection-Set-int-null?", LINK_OVL);
	addOneArgMethod("size",
		Wrapper<_Collection_Set_int__ >::name, 
		"Collection-Set-int-size", LINK_NEW);
	addTwoArgMethod("eqv?",
		Wrapper<_Collection_Set_int__ >::name, 
		Wrapper<_Collection_Set_int__ >::name, 
		"Collection-Set-int-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Collection_Set_int__ >::name, 
		"Collection-Set-int-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Collection_Set_int__ >::name, 
		"Collection-Set-int-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Collection_Set_int__ >::name, 
		"Collection-Set-int->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Collection_Set_int__ >::name, 
		"Collection-Set-int->=", LINK_OVL);
	addTwoArgMethod("member",
		Wrapper<_Set_int_ >::name, 
		Wrapper<_Collection_Set_int__ >::name, 
		"Collection-Set-int-member", LINK_OVL);
	addTwoArgMethod("ref",
		Wrapper<_Collection_Set_int__ >::name, 
		"<integer>",
		"Collection-Set-int-ref", LINK_NEW);
	addOneArgMethod("clear!",
		Wrapper<_Collection_Set_int__ >::name, 
		"Collection-Set-int-clear!", LINK_NEW);
	addTwoArgMethod("insert!",
		Wrapper<_Set_int_ >::name, 
		Wrapper<_Collection_Set_int__ >::name, 
		"Collection-Set-int-insert!", LINK_NEW);
	addTwoArgMethod("append!",
		Wrapper<_Set_int_ >::name, 
		Wrapper<_Collection_Set_int__ >::name, 
		"Collection-Set-int-append!", LINK_NEW);
	addTwoArgMethod("remove!",
		Wrapper<_Set_int_ >::name, 
		Wrapper<_Collection_Set_int__ >::name, 
		"Collection-Set-int-remove!", LINK_NEW);
	addArbMethod("+",
		Wrapper<_Collection_Set_int__ >::name, 
		"Collection-Set-int-+", LINK_OVL);
	addArbMethod("^",
		Wrapper<_Collection_Set_int__ >::name, 
		"Collection-Set-int-^", LINK_NEW);
	addArbMethod("-",
		Wrapper<_Collection_Set_int__ >::name, 
		"Collection-Set-int--", LINK_OVL);
	addTwoArgMethod("cartesian-product",
		Wrapper<_Set_int_ >::name, 
		Wrapper<_Set_int_ >::name, 
		"Collection-Set-int-cartesian-product", LINK_NEW);
	addTwoArgMethod("choose",
		Wrapper<_Set_int_ >::name, 
		"<integer>",
		"Collection-Set-int-choose", LINK_NEW);
	addOneArgMethod("power-set",
		Wrapper<_Set_int_ >::name, 
		"Collection-Set-int-power-set", LINK_NEW);
	addOneArgMethod("permutations",
		Wrapper<_Set_int_ >::name, 
		"Collection-Set-int-permutations", LINK_NEW);
	addTwoArgMethod("permutation",
		Wrapper<_Set_int_ >::name, 
		"<integer>",
		"Collection-Set-int-permutation", LINK_NEW);
	addOneArgMethod("permutation-rank",
		Wrapper<_Set_int_ >::name, 
		"Collection-Set-int-permutation-rank", LINK_NEW);
	genExtra_Collection_Set_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Collection_SubSet_int__()
{
	Wrapper<_Collection_SubSet_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_SubSet_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_SubSet_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_SubSet_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_SubSet_int__Methods(void);

PRIMITIVE STk_init_methods__Collection_SubSet_int__()
{
	genExtra_Collection_SubSet_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Collection_char__()
{
	Wrapper<_Collection_char__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_char__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_char_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_char_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_char_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_char__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_char__Methods(void);

PRIMITIVE STk_init_methods__Collection_char__()
{
	STk_add_new_cpp_primitive("collection-char?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::collectionP);
	STk_add_new_cpp_primitive("mset-char1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::buildMSet);
	STk_add_new_cpp_primitive("set-char1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::buildSet);
	STk_add_new_cpp_primitive("sequence-char1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::buildSequence);
	STk_add_new_cpp_primitive("Collection-char-sorted?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::sortedLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-size", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::sizeLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-null?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::nullLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::eqvLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::lthLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::leLinkCollection);
	STk_add_new_cpp_primitive("Collection-char->", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::grLinkCollection);
	STk_add_new_cpp_primitive("Collection-char->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::geLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-member", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::memberLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-clear!", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::clearLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-insert!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::insertLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-append!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::appendLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-remove!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::removeLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-occurrences", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::occurrencesLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::refLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-rank", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::rankLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-+", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::unionLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-^", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::intersectionLinkCollection);
	STk_add_new_cpp_primitive("Collection-char--", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::differenceLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::subsetLinkCollection);
	STk_add_new_cpp_primitive("Collection-char-proper-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::properSubsetLinkCollection);
	STk_add_new_cpp_primitive("list->mset-char", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::stkList2LinkMSet);
	STk_add_new_cpp_primitive("list->set-char", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::stkList2LinkSet);
	STk_add_new_cpp_primitive("list->sequence-char", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::stkList2LinkSequence);
	STk_add_new_cpp_primitive("mset-char->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::collection2STkList);
	STk_add_new_cpp_primitive("set-char->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::collection2STkList);
	STk_add_new_cpp_primitive("sequence-char->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::collection2STkList);
	STk_add_new_cpp_primitive("mset-char->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::collection2STkString);
	STk_add_new_cpp_primitive("set-char->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::collection2STkString);
	STk_add_new_cpp_primitive("sequence-char->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_char_>::collection2STkString);

	addListMethod("mset-char",
		"mset-char1", LINK_NEW);
	addListMethod("set-char",
		"set-char1", LINK_NEW);
	addListMethod("sequence-char",
		"sequence-char1", LINK_NEW);
	addOneArgMethod("null?",
		Wrapper<_Collection_char__ >::name, 
		"Collection-char-null?", LINK_OVL);
	addOneArgMethod("size",
		Wrapper<_Collection_char__ >::name, 
		"Collection-char-size", LINK_NEW);
	addTwoArgMethod("eqv?",
		Wrapper<_Collection_char__ >::name, 
		Wrapper<_Collection_char__ >::name, 
		"Collection-char-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Collection_char__ >::name, 
		"Collection-char-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Collection_char__ >::name, 
		"Collection-char-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Collection_char__ >::name, 
		"Collection-char->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Collection_char__ >::name, 
		"Collection-char->=", LINK_OVL);
	addTwoArgMethod("member",
		Wrapper<_char_ >::name, 
		Wrapper<_Collection_char__ >::name, 
		"Collection-char-member", LINK_OVL);
	addTwoArgMethod("ref",
		Wrapper<_Collection_char__ >::name, 
		"<integer>",
		"Collection-char-ref", LINK_NEW);
	addOneArgMethod("clear!",
		Wrapper<_Collection_char__ >::name, 
		"Collection-char-clear!", LINK_NEW);
	addTwoArgMethod("insert!",
		Wrapper<_char_ >::name, 
		Wrapper<_Collection_char__ >::name, 
		"Collection-char-insert!", LINK_NEW);
	addTwoArgMethod("append!",
		Wrapper<_char_ >::name, 
		Wrapper<_Collection_char__ >::name, 
		"Collection-char-append!", LINK_NEW);
	addTwoArgMethod("remove!",
		Wrapper<_char_ >::name, 
		Wrapper<_Collection_char__ >::name, 
		"Collection-char-remove!", LINK_NEW);
	addArbMethod("+",
		Wrapper<_Collection_char__ >::name, 
		"Collection-char-+", LINK_OVL);
	addArbMethod("^",
		Wrapper<_Collection_char__ >::name, 
		"Collection-char-^", LINK_NEW);
	addArbMethod("-",
		Wrapper<_Collection_char__ >::name, 
		"Collection-char--", LINK_OVL);
	genExtra_Collection_char__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Collection_int_()
{
	Wrapper<_Collection_int_>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_int_>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_int>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_int>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_int>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_int_>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_int_Methods(void);

PRIMITIVE STk_init_methods__Collection_int_()
{
	STk_add_new_cpp_primitive("collection-int?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::collectionP);
	STk_add_new_cpp_primitive("mset-int1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::buildMSet);
	STk_add_new_cpp_primitive("set-int1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::buildSet);
	STk_add_new_cpp_primitive("sequence-int1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::buildSequence);
	STk_add_new_cpp_primitive("Collection-int-sorted?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::sortedLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-size", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::sizeLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-null?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::nullLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::eqvLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::lthLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::leLinkCollection);
	STk_add_new_cpp_primitive("Collection-int->", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::grLinkCollection);
	STk_add_new_cpp_primitive("Collection-int->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::geLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-member", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::memberLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-clear!", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::clearLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-insert!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::insertLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-append!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::appendLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-remove!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::removeLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-occurrences", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::occurrencesLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::refLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-rank", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::rankLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-+", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::unionLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-^", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::intersectionLinkCollection);
	STk_add_new_cpp_primitive("Collection-int--", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::differenceLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::subsetLinkCollection);
	STk_add_new_cpp_primitive("Collection-int-proper-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::properSubsetLinkCollection);
	STk_add_new_cpp_primitive("list->mset-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::stkList2LinkMSet);
	STk_add_new_cpp_primitive("list->set-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::stkList2LinkSet);
	STk_add_new_cpp_primitive("list->sequence-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::stkList2LinkSequence);
	STk_add_new_cpp_primitive("mset-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::collection2STkList);
	STk_add_new_cpp_primitive("set-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::collection2STkList);
	STk_add_new_cpp_primitive("sequence-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::collection2STkList);
	STk_add_new_cpp_primitive("mset-int->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::collection2STkString);
	STk_add_new_cpp_primitive("set-int->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::collection2STkString);
	STk_add_new_cpp_primitive("sequence-int->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_int>::collection2STkString);

	addListMethod("mset-int",
		"mset-int1", LINK_NEW);
	addListMethod("set-int",
		"set-int1", LINK_NEW);
	addListMethod("sequence-int",
		"sequence-int1", LINK_NEW);
	addOneArgMethod("null?",
		Wrapper<_Collection_int_ >::name, 
		"Collection-int-null?", LINK_OVL);
	addOneArgMethod("size",
		Wrapper<_Collection_int_ >::name, 
		"Collection-int-size", LINK_NEW);
	addTwoArgMethod("eqv?",
		Wrapper<_Collection_int_ >::name, 
		Wrapper<_Collection_int_ >::name, 
		"Collection-int-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Collection_int_ >::name, 
		"Collection-int-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Collection_int_ >::name, 
		"Collection-int-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Collection_int_ >::name, 
		"Collection-int->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Collection_int_ >::name, 
		"Collection-int->=", LINK_OVL);
	addTwoArgMethod("member",
		Wrapper<_int >::name, 
		Wrapper<_Collection_int_ >::name, 
		"Collection-int-member", LINK_OVL);
	addTwoArgMethod("ref",
		Wrapper<_Collection_int_ >::name, 
		"<integer>",
		"Collection-int-ref", LINK_NEW);
	addOneArgMethod("clear!",
		Wrapper<_Collection_int_ >::name, 
		"Collection-int-clear!", LINK_NEW);
	addTwoArgMethod("insert!",
		Wrapper<_int >::name, 
		Wrapper<_Collection_int_ >::name, 
		"Collection-int-insert!", LINK_NEW);
	addTwoArgMethod("append!",
		Wrapper<_int >::name, 
		Wrapper<_Collection_int_ >::name, 
		"Collection-int-append!", LINK_NEW);
	addTwoArgMethod("remove!",
		Wrapper<_int >::name, 
		Wrapper<_Collection_int_ >::name, 
		"Collection-int-remove!", LINK_NEW);
	addArbMethod("+",
		Wrapper<_Collection_int_ >::name, 
		"Collection-int-+", LINK_OVL);
	addArbMethod("^",
		Wrapper<_Collection_int_ >::name, 
		"Collection-int-^", LINK_NEW);
	addArbMethod("-",
		Wrapper<_Collection_int_ >::name, 
		"Collection-int--", LINK_OVL);
	genExtra_Collection_int_Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Container_MSet_int__()
{
	Wrapper<_Container_MSet_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_MSet_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_MSet_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_MSet_int__Methods(void);

PRIMITIVE STk_init_methods__Container_MSet_int__()
{
	genExtra_Container_MSet_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Container_Sequence_int__()
{
	Wrapper<_Container_Sequence_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_Sequence_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_Sequence_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_Sequence_int__Methods(void);

PRIMITIVE STk_init_methods__Container_Sequence_int__()
{
	genExtra_Container_Sequence_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Container_Set_char___()
{
	Wrapper<_Container_Set_char___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_Set_char___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_Set_char___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_Set_char___Methods(void);

PRIMITIVE STk_init_methods__Container_Set_char___()
{
	genExtra_Container_Set_char___Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Container_Set_int__()
{
	Wrapper<_Container_Set_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_Set_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_Set_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_Set_int__Methods(void);

PRIMITIVE STk_init_methods__Container_Set_int__()
{
	genExtra_Container_Set_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Container_SubSet_int__()
{
	Wrapper<_Container_SubSet_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_SubSet_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_SubSet_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_SubSet_int__Methods(void);

PRIMITIVE STk_init_methods__Container_SubSet_int__()
{
	genExtra_Container_SubSet_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Container_char__()
{
	Wrapper<_Container_char__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_char__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_char__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_char__Methods(void);

PRIMITIVE STk_init_methods__Container_char__()
{
	genExtra_Container_char__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Container_int_()
{
	Wrapper<_Container_int_>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_int_>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_int_>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_int_Methods(void);

PRIMITIVE STk_init_methods__Container_int_()
{
	genExtra_Container_int_Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__DList_int_()
{
	Wrapper<_DList_int_>::type = STk_new_CXXwrapper_id(
			Wrapper<_DList_int_>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_DList_int_>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_DList_int_Methods(void);

PRIMITIVE STk_init_methods__DList_int_()
{
	genExtra_DList_int_Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__List_MSet_int__()
{
	Wrapper<_List_MSet_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_MSet_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_MSet_int_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_MSet_int_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_MSet_int_>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_MSet_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_MSet_int__Methods(void);

PRIMITIVE STk_init_methods__List_MSet_int__()
{
	STk_add_new_cpp_primitive("List-MSet-int-make", tc_subr_0, 
	(PRIMITIVE (*)(...))  ListWrapper<_MSet_int_>::makeLinkList);
	STk_add_new_cpp_primitive("List-MSet-int?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_MSet_int_>::linkListP);
	STk_add_new_cpp_primitive("list->List-MSet-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_MSet_int_>::stkList2LinkList);
	STk_add_new_cpp_primitive("List-MSet-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_MSet_int_>::linkList2STkList);
	genExtra_List_MSet_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__List_Sequence_int__()
{
	Wrapper<_List_Sequence_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_Sequence_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Sequence_int_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Sequence_int_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Sequence_int_>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_Sequence_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_Sequence_int__Methods(void);

PRIMITIVE STk_init_methods__List_Sequence_int__()
{
	STk_add_new_cpp_primitive("List-Sequence-int-make", tc_subr_0, 
	(PRIMITIVE (*)(...))  ListWrapper<_Sequence_int_>::makeLinkList);
	STk_add_new_cpp_primitive("List-Sequence-int?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Sequence_int_>::linkListP);
	STk_add_new_cpp_primitive("list->List-Sequence-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Sequence_int_>::stkList2LinkList);
	STk_add_new_cpp_primitive("List-Sequence-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Sequence_int_>::linkList2STkList);
	genExtra_List_Sequence_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__List_Set_char___()
{
	Wrapper<_List_Set_char___>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_Set_char___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Set_char__>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Set_char__>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Set_char__>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_Set_char___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_Set_char___Methods(void);

PRIMITIVE STk_init_methods__List_Set_char___()
{
	STk_add_new_cpp_primitive("List-Set-char-make", tc_subr_0, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_char__>::makeLinkList);
	STk_add_new_cpp_primitive("List-Set-char?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_char__>::linkListP);
	STk_add_new_cpp_primitive("list->List-Set-char", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_char__>::stkList2LinkList);
	STk_add_new_cpp_primitive("List-Set-char->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_char__>::linkList2STkList);
	genExtra_List_Set_char___Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__List_Set_int__()
{
	Wrapper<_List_Set_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_Set_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Set_int_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Set_int_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Set_int_>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_Set_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_Set_int__Methods(void);

PRIMITIVE STk_init_methods__List_Set_int__()
{
	STk_add_new_cpp_primitive("List-Set-int-make", tc_subr_0, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_int_>::makeLinkList);
	STk_add_new_cpp_primitive("List-Set-int?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_int_>::linkListP);
	STk_add_new_cpp_primitive("list->List-Set-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_int_>::stkList2LinkList);
	STk_add_new_cpp_primitive("List-Set-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_int_>::linkList2STkList);
	genExtra_List_Set_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__List_SubSet_int__()
{
	Wrapper<_List_SubSet_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_SubSet_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_SubSet_int_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_SubSet_int_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_SubSet_int_>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_SubSet_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_SubSet_int__Methods(void);

PRIMITIVE STk_init_methods__List_SubSet_int__()
{
	genExtra_List_SubSet_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__List_char__()
{
	Wrapper<_List_char__>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_char__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_char_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_char_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_char_>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_char__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_char__Methods(void);

PRIMITIVE STk_init_methods__List_char__()
{
	STk_add_new_cpp_primitive("List-char-make", tc_subr_0, 
	(PRIMITIVE (*)(...))  ListWrapper<_char_>::makeLinkList);
	STk_add_new_cpp_primitive("List-char?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_char_>::linkListP);
	STk_add_new_cpp_primitive("list->List-char", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_char_>::stkList2LinkList);
	STk_add_new_cpp_primitive("List-char->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_char_>::linkList2STkList);
	genExtra_List_char__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__List_int_()
{
	Wrapper<_List_int_>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_int_>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_int>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_int>::markTypedList,
			(void (*)(SCM x))ListWrapper<_int>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_int_>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_int_Methods(void);

PRIMITIVE STk_init_methods__List_int_()
{
	STk_add_new_cpp_primitive("List-int-make", tc_subr_0, 
	(PRIMITIVE (*)(...))  ListWrapper<_int>::makeLinkList);
	STk_add_new_cpp_primitive("List-int?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_int>::linkListP);
	STk_add_new_cpp_primitive("list->List-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_int>::stkList2LinkList);
	STk_add_new_cpp_primitive("List-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_int>::linkList2STkList);
	genExtra_List_int_Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__MSet_MSet_int__()
{
	Wrapper<_MSet_MSet_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_MSet_int__>::name, 
			Wrapper<Collection<MSet<int> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_MSet_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_MSet_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_MSet_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_MSet_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_MSet_int__Methods(void);

PRIMITIVE STk_init_methods__MSet_MSet_int__()
{
	genExtra_MSet_MSet_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__MSet_Sequence_int__()
{
	Wrapper<_MSet_Sequence_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_Sequence_int__>::name, 
			Wrapper<Collection<Sequence<int> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Sequence_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_Sequence_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_Sequence_int__Methods(void);

PRIMITIVE STk_init_methods__MSet_Sequence_int__()
{
	genExtra_MSet_Sequence_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__MSet_Set_char___()
{
	Wrapper<_MSet_Set_char___>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_Set_char___>::name, 
			Wrapper<Collection<char*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_char__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_char__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_char__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_Set_char___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_Set_char___Methods(void);

PRIMITIVE STk_init_methods__MSet_Set_char___()
{
	genExtra_MSet_Set_char___Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__MSet_Set_int__()
{
	Wrapper<_MSet_Set_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_Set_int__>::name, 
			Wrapper<Collection<Set<int> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_Set_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_Set_int__Methods(void);

PRIMITIVE STk_init_methods__MSet_Set_int__()
{
	genExtra_MSet_Set_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__MSet_SubSet_int__()
{
	Wrapper<_MSet_SubSet_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_SubSet_int__>::name, 
			Wrapper<Collection<SubSet<int> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_SubSet_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_SubSet_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_SubSet_int__Methods(void);

PRIMITIVE STk_init_methods__MSet_SubSet_int__()
{
	genExtra_MSet_SubSet_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__MSet_char__()
{
	Wrapper<_MSet_char__>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_char__>::name, 
			Wrapper<Collection<char*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_char_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_char_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_char_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_char__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_char__Methods(void);

PRIMITIVE STk_init_methods__MSet_char__()
{
	genExtra_MSet_char__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__MSet_int_()
{
	Wrapper<_MSet_int_>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_int_>::name, 
			Wrapper<Collection<int> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_int>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_int>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_int>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_int_>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_int_Methods(void);

PRIMITIVE STk_init_methods__MSet_int_()
{
	genExtra_MSet_int_Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Matrix_double_()
{
	Wrapper<_Matrix_double_>::type = STk_new_CXXwrapper_id(
			Wrapper<_Matrix_double_>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			MatrixWrapper<_double>::displayTypedMatrix,
			(void (*)(SCM x))MatrixWrapper<_double>::markTypedMatrix,
			(void (*)(SCM x))MatrixWrapper<_double>::freeTypedMatrix);
	Tcl_InitHashTable(&Register<_Matrix_double_>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Matrix_double_Methods(void);

PRIMITIVE STk_init_methods__Matrix_double_()
{
	STk_add_new_cpp_primitive("Matrix-double-make", tc_subr_2, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::makeLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-double-make2", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::makeFilledLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-double-matrix-ref", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::refLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-double?", tc_subr_1, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::linkMatrixP);
	STk_add_new_cpp_primitive("matrix-double", tc_subr_2, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::makeLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-double-matrix-fill!", tc_subr_2, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::fillLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-double-matrix-copy", tc_subr_1, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::copyLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-double-matrix-set!", tc_lsubr, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::setLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-double-matrix-rows", tc_subr_1, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::numRowsLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-double-matrix-cols", tc_subr_1, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::numColsLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-double-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::eqvLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-double-multiply", tc_subr_2, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::multiply);
	STk_add_new_cpp_primitive("Matrix-double-sum", tc_subr_2, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::sum);
	STk_add_new_cpp_primitive("Matrix-double-transpose", tc_subr_1, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::transpose);
	STk_add_new_cpp_primitive("Matrix-double-add-rows", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::addRows);
	STk_add_new_cpp_primitive("Matrix-double-add-cols", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::addCols);
	STk_add_new_cpp_primitive("Matrix-double-swap-rows", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::swapRows);
	STk_add_new_cpp_primitive("Matrix-double-swap-cols", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::swapCols);
	STk_add_new_cpp_primitive("Matrix-double-scalar-mult-row", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::scalarMultRow);
	STk_add_new_cpp_primitive("Matrix-double-scalar-mult-col", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::scalarMultCol);
	STk_add_new_cpp_primitive("list->Matrix-double", tc_subr_1, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::stkList2LinkMatrix);
	STk_add_new_cpp_primitive("Matrix-double->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_double>::linkMatrix2STkList);

	addOneArgMethod("matrix-copy",
		Wrapper<_Matrix_double_ >::name, 
		"Matrix-double-matrix-copy", LINK_OVL);
	addOneArgMethod("matrix-rows",
		Wrapper<_Matrix_double_ >::name, 
		"Matrix-double-matrix-rows", LINK_OVL);
	addOneArgMethod("matrix-cols",
		Wrapper<_Matrix_double_ >::name, 
		"Matrix-double-matrix-cols", LINK_OVL);
	addOneArgMethod("transpose",
		Wrapper<_Matrix_double_ >::name, 
		"Matrix-double-transpose", LINK_OVL);
	addThreeArgMethod("matrix-ref",
		Wrapper<_Matrix_double_ >::name, 
		"<integer>",
		"<integer>",
		"Matrix-double-matrix-ref", LINK_OVL);
	addTwoArgMethod("matrix-fill!",
		Wrapper<_Matrix_double_ >::name, 
		"<number>",
		"Matrix-double-matrix-fill!", LINK_OVL);
	addFourArgMethod("matrix-set!",
		Wrapper<_Matrix_double_ >::name, 
		"<integer>",
		"<integer>",
		"<number>",
		"Matrix-double-matrix-set!", LINK_OVL);
	addTwoArgMethod("eqv?",
		Wrapper<_Matrix_double_ >::name, 
		Wrapper<_Matrix_double_ >::name, 
		"Matrix-double-eqv?", LINK_OVL);
	addThreeArgMethod("add-rows",
		Wrapper<_Matrix_double_ >::name, 
		"<integer>",
		"<integer>",
		"Matrix-double-add-rows", LINK_OVL);
	addThreeArgMethod("add-cols",
		Wrapper<_Matrix_double_ >::name, 
		"<integer>",
		"<integer>",
		"Matrix-double-add-cols", LINK_OVL);
	addThreeArgMethod("swap-rows",
		Wrapper<_Matrix_double_ >::name, 
		"<integer>",
		"<integer>",
		"Matrix-double-swap-rows", LINK_OVL);
	addThreeArgMethod("swap-cols",
		Wrapper<_Matrix_double_ >::name, 
		"<integer>",
		"<integer>",
		"Matrix-double-swap-cols", LINK_OVL);
	addThreeArgMethod("scalar-mult-row",
		Wrapper<_Matrix_double_ >::name, 
		"<integer>",
		"<number>",
		"Matrix-double-scalar-mult-row", LINK_OVL);
	addThreeArgMethod("scalar-mult-col",
		Wrapper<_Matrix_double_ >::name, 
		"<integer>",
		"<number>",
		"Matrix-double-scalar-mult-col", LINK_OVL);
	genExtra_Matrix_double_Methods();
	return UNDEFINED;
}
///home/berryj/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>
#include <LINK/stkWrapper/MatrixWrapper.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))


PRIMITIVE STk_init__Matrix_int_()
{
	Wrapper<_Matrix_int_>::type = STk_new_CXXwrapper_id(
			Wrapper<_Matrix_int_>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			MatrixWrapper<_int>::displayTypedMatrix,
			(void (*)(SCM x))MatrixWrapper<_int>::markTypedMatrix,
			(void (*)(SCM x))MatrixWrapper<_int>::freeTypedMatrix);
	Tcl_InitHashTable(&Register<_Matrix_int_>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Matrix_int_Methods(void);

PRIMITIVE STk_init_methods__Matrix_int_()
{
	STk_add_new_cpp_primitive("Matrix-int-make", tc_subr_2, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::makeLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-int-make2", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::makeFilledLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-int-matrix-ref", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::refLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-int?", tc_subr_1, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::linkMatrixP);
	STk_add_new_cpp_primitive("matrix-int", tc_subr_2, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::makeLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-int-matrix-fill!", tc_subr_2, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::fillLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-int-matrix-copy", tc_subr_1, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::copyLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-int-matrix-set!", tc_lsubr, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::setLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-int-matrix-rows", tc_subr_1, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::numRowsLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-int-matrix-cols", tc_subr_1, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::numColsLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-int-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::eqvLinkMatrix);
	STk_add_new_cpp_primitive("Matrix-int-multiply", tc_subr_2, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::multiply);
	STk_add_new_cpp_primitive("Matrix-int-sum", tc_subr_2, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::sum);
	STk_add_new_cpp_primitive("Matrix-int-transpose", tc_subr_1, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::transpose);
	STk_add_new_cpp_primitive("Matrix-int-add-rows", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::addRows);
	STk_add_new_cpp_primitive("Matrix-int-add-cols", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::addCols);
	STk_add_new_cpp_primitive("Matrix-int-swap-rows", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::swapRows);
	STk_add_new_cpp_primitive("Matrix-int-swap-cols", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::swapCols);
	STk_add_new_cpp_primitive("Matrix-int-scalar-mult-row", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::scalarMultRow);
	STk_add_new_cpp_primitive("Matrix-int-scalar-mult-col", tc_subr_3, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::scalarMultCol);
	STk_add_new_cpp_primitive("list->Matrix-int", tc_subr_1, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::stkList2LinkMatrix);
	STk_add_new_cpp_primitive("Matrix-int->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  MatrixWrapper<_int>::linkMatrix2STkList);

	/*addOneArgMethod("matrix-copy",
		Wrapper<_Matrix_int_ >::name, 
		"Matrix-int-matrix-copy", LINK_OVL);
	addOneArgMethod("matrix-rows",
		Wrapper<_Matrix_int_ >::name, 
		"Matrix-int-matrix-rows", LINK_OVL);
	addOneArgMethod("matrix-cols",
		Wrapper<_Matrix_int_ >::name, 
		"Matrix-int-matrix-cols", LINK_OVL);
	addOneArgMethod("transpose",
		Wrapper<_Matrix_int_ >::name, 
		"Matrix-int-transpose", LINK_OVL);
	addThreeArgMethod("matrix-ref",
		Wrapper<_Matrix_int_ >::name, 
		"<integer>",
		"<integer>",
		"Matrix-int-matrix-ref", LINK_OVL);
	addTwoArgMethod("matrix-fill!",
		Wrapper<_Matrix_int_ >::name, 
		"<number>",
		"Matrix-int-matrix-fill!", LINK_OVL);
	addFourArgMethod("matrix-set!",
		Wrapper<_Matrix_int_ >::name, 
		"<integer>",
		"<integer>",
		"<number>",
		"Matrix-int-matrix-set!", LINK_OVL);
	addTwoArgMethod("eqv?",
		Wrapper<_Matrix_int_ >::name, 
		Wrapper<_Matrix_int_ >::name, 
		"Matrix-int-eqv?", LINK_OVL);
	addThreeArgMethod("add-rows",
		Wrapper<_Matrix_int_ >::name, 
		"<integer>",
		"<integer>",
		"Matrix-int-add-rows", LINK_OVL);
	addThreeArgMethod("add-cols",
		Wrapper<_Matrix_int_ >::name, 
		"<integer>",
		"<integer>",
		"Matrix-int-add-cols", LINK_OVL);
	addThreeArgMethod("swap-rows",
		Wrapper<_Matrix_int_ >::name, 
		"<integer>",
		"<integer>",
		"Matrix-int-swap-rows", LINK_OVL);
	addThreeArgMethod("swap-cols",
		Wrapper<_Matrix_int_ >::name, 
		"<integer>",
		"<integer>",
		"Matrix-int-swap-cols", LINK_OVL);
	addThreeArgMethod("scalar-mult-row",
		Wrapper<_Matrix_int_ >::name, 
		"<integer>",
		"<number>",
		"Matrix-int-scalar-mult-row", LINK_OVL);
	addThreeArgMethod("scalar-mult-col",
		Wrapper<_Matrix_int_ >::name, 
		"<integer>",
		"<number>",
		"Matrix-int-scalar-mult-col", LINK_OVL);
	genExtra_Matrix_int_Methods();*/
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Sequence_MSet_int__()
{
	Wrapper<_Sequence_MSet_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_MSet_int__>::name, 
			Wrapper<Collection<MSet<int> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_MSet_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_MSet_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_MSet_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_MSet_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_MSet_int__Methods(void);

PRIMITIVE STk_init_methods__Sequence_MSet_int__()
{
	genExtra_Sequence_MSet_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Sequence_Sequence_int__()
{
	Wrapper<_Sequence_Sequence_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_Sequence_int__>::name, 
			Wrapper<Collection<Sequence<int> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Sequence_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_Sequence_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_Sequence_int__Methods(void);

PRIMITIVE STk_init_methods__Sequence_Sequence_int__()
{
	genExtra_Sequence_Sequence_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Sequence_Set_char___()
{
	Wrapper<_Sequence_Set_char___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_Set_char___>::name, 
			Wrapper<Collection<char*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_char__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_char__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_char__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_Set_char___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_Set_char___Methods(void);

PRIMITIVE STk_init_methods__Sequence_Set_char___()
{
	genExtra_Sequence_Set_char___Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Sequence_Set_int__()
{
	Wrapper<_Sequence_Set_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_Set_int__>::name, 
			Wrapper<Collection<Set<int> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_Set_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_Set_int__Methods(void);

PRIMITIVE STk_init_methods__Sequence_Set_int__()
{
	genExtra_Sequence_Set_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Sequence_SubSet_int__()
{
	Wrapper<_Sequence_SubSet_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_SubSet_int__>::name, 
			Wrapper<Collection<SubSet<int> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_SubSet_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_SubSet_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_SubSet_int__Methods(void);

PRIMITIVE STk_init_methods__Sequence_SubSet_int__()
{
	genExtra_Sequence_SubSet_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Sequence_char__()
{
	Wrapper<_Sequence_char__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_char__>::name, 
			Wrapper<Collection<char*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_char_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_char_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_char_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_char__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_char__Methods(void);

PRIMITIVE STk_init_methods__Sequence_char__()
{
	genExtra_Sequence_char__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Sequence_int_()
{
	Wrapper<_Sequence_int_>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_int_>::name, 
			Wrapper<Collection<int> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_int>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_int>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_int>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_int_>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_int_Methods(void);

PRIMITIVE STk_init_methods__Sequence_int_()
{
	genExtra_Sequence_int_Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Set_MSet_int__()
{
	Wrapper<_Set_MSet_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_MSet_int__>::name, 
			Wrapper<MSet<MSet<int> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_MSet_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_MSet_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_MSet_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_MSet_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_MSet_int__Methods(void);

PRIMITIVE STk_init_methods__Set_MSet_int__()
{
	genExtra_Set_MSet_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Set_Sequence_int__()
{
	Wrapper<_Set_Sequence_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_Sequence_int__>::name, 
			Wrapper<MSet<Sequence<int> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Sequence_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_Sequence_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_Sequence_int__Methods(void);

PRIMITIVE STk_init_methods__Set_Sequence_int__()
{
	genExtra_Set_Sequence_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Set_Set_char___()
{
	Wrapper<_Set_Set_char___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_Set_char___>::name, 
			Wrapper<MSet<char*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_char__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_char__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_char__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_Set_char___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_Set_char___Methods(void);

PRIMITIVE STk_init_methods__Set_Set_char___()
{
	genExtra_Set_Set_char___Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Set_Set_int__()
{
	Wrapper<_Set_Set_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_Set_int__>::name, 
			Wrapper<MSet<Set<int> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_Set_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_Set_int__Methods(void);

PRIMITIVE STk_init_methods__Set_Set_int__()
{
	genExtra_Set_Set_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Set_SubSet_int__()
{
	Wrapper<_Set_SubSet_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_SubSet_int__>::name, 
			Wrapper<MSet<SubSet<int> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_SubSet_int_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_int_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_int_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_SubSet_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_SubSet_int__Methods(void);

PRIMITIVE STk_init_methods__Set_SubSet_int__()
{
	genExtra_Set_SubSet_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Set_char__()
{
	Wrapper<_Set_char__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_char__>::name, 
			Wrapper<MSet<char*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_char_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_char_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_char_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_char__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_char__Methods(void);

PRIMITIVE STk_init_methods__Set_char__()
{
	genExtra_Set_char__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__Set_int_()
{
	Wrapper<_Set_int_>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_int_>::name, 
			Wrapper<MSet<int> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_int>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_int>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_int>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_int_>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_int_Methods(void);

PRIMITIVE STk_init_methods__Set_int_()
{
	genExtra_Set_int_Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__SortedArray_char__()
{
	Wrapper<_SortedArray_char__>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedArray_char__>::name, 
			Wrapper<Array<char*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			ArrayWrapper<_char_>::displayTypedArray,
			(void (*)(SCM x))ArrayWrapper<_char_>::markTypedArray,
			(void (*)(SCM x))ArrayWrapper<_char_>::freeTypedArray);
	Tcl_InitHashTable(&Register<_SortedArray_char__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedArray_char__Methods(void);

PRIMITIVE STk_init_methods__SortedArray_char__()
{
	genExtra_SortedArray_char__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__SortedArray_int_()
{
	Wrapper<_SortedArray_int_>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedArray_int_>::name, 
			Wrapper<Array<int> >::name,
			(void (*)(SCM x, SCM port, int mode))
			ArrayWrapper<_int>::displayTypedArray,
			(void (*)(SCM x))ArrayWrapper<_int>::markTypedArray,
			(void (*)(SCM x))ArrayWrapper<_int>::freeTypedArray);
	Tcl_InitHashTable(&Register<_SortedArray_int_>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedArray_int_Methods(void);

PRIMITIVE STk_init_methods__SortedArray_int_()
{
	genExtra_SortedArray_int_Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__SortedList_MSet_int__()
{
	Wrapper<_SortedList_MSet_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_MSet_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_MSet_int_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_MSet_int_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_MSet_int_>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_MSet_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_MSet_int__Methods(void);

PRIMITIVE STk_init_methods__SortedList_MSet_int__()
{
	genExtra_SortedList_MSet_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__SortedList_Sequence_int__()
{
	Wrapper<_SortedList_Sequence_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_Sequence_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Sequence_int_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Sequence_int_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Sequence_int_>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_Sequence_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_Sequence_int__Methods(void);

PRIMITIVE STk_init_methods__SortedList_Sequence_int__()
{
	genExtra_SortedList_Sequence_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__SortedList_Set_char___()
{
	Wrapper<_SortedList_Set_char___>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_Set_char___>::name, 
			Wrapper<List<char*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Set_char__>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Set_char__>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Set_char__>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_Set_char___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_Set_char___Methods(void);

PRIMITIVE STk_init_methods__SortedList_Set_char___()
{
	genExtra_SortedList_Set_char___Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__SortedList_Set_int__()
{
	Wrapper<_SortedList_Set_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_Set_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Set_int_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Set_int_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Set_int_>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_Set_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_Set_int__Methods(void);

PRIMITIVE STk_init_methods__SortedList_Set_int__()
{
	genExtra_SortedList_Set_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__SortedList_SubSet_int__()
{
	Wrapper<_SortedList_SubSet_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_SubSet_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_SubSet_int_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_SubSet_int_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_SubSet_int_>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_SubSet_int__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_SubSet_int__Methods(void);

PRIMITIVE STk_init_methods__SortedList_SubSet_int__()
{
	genExtra_SortedList_SubSet_int__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__SortedList_char__()
{
	Wrapper<_SortedList_char__>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_char__>::name, 
			Wrapper<List<char*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_char_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_char_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_char_>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_char__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_char__Methods(void);

PRIMITIVE STk_init_methods__SortedList_char__()
{
	genExtra_SortedList_char__Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__SortedList_int_()
{
	Wrapper<_SortedList_int_>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_int_>::name, 
			Wrapper<List<int> >::name,
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_int>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_int>::markTypedList,
			(void (*)(SCM x))ListWrapper<_int>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_int_>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_int_Methods(void);

PRIMITIVE STk_init_methods__SortedList_int_()
{
	genExtra_SortedList_int_Methods();
	return UNDEFINED;
}
///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))


PRIMITIVE STk_init__SubSet_int_()
{
	Wrapper<_SubSet_int_>::type = STk_new_CXXwrapper_id(
			Wrapper<_SubSet_int_>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_subset_int,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_SubSet_int_>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SubSet_int_Methods(void);

PRIMITIVE STk_init_methods__SubSet_int_()
{
	genExtra_SubSet_int_Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_charIS_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) (!_charCXX_IS_DATA(x))


PRIMITIVE STk_init__char()
{
	Wrapper<_char>::type = STk_new_CXXwrapper_id(
			Wrapper<_char>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_char,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_char);
	Tcl_InitHashTable(&Register<_char>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_charMethods(void);

PRIMITIVE STk_init_methods__char()
{
	genExtra_charMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_char_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) (!_char_CXX_IS_DATA(x))


static SCM is_char_(SCM i)
{
	if (_char_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init__char_()
{
	Wrapper<_char_>::type = STk_new_CXXwrapper_id(
			Wrapper<_char_>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_charptr,
			(void (*)(SCM x))mark_charptr,
			(void (*)(SCM x))free_charptr);
	Tcl_InitHashTable(&Register<_char_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("char?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_char_);
	return UNDEFINED;
}

void genExtra_char_Methods(void);

PRIMITIVE STk_init_methods__char_()
{
	genExtra_char_Methods();
	return UNDEFINED;
}
///home/berryj/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))


PRIMITIVE STk_init__double()
{
	Wrapper<_double>::type = STk_new_CXXwrapper_id(
			Wrapper<_double>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_double,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_double);
	Tcl_InitHashTable(&Register<_double>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_doubleMethods(void);

PRIMITIVE STk_init_methods__double()
{
	genExtra_doubleMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_intIS_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) (!_intCXX_IS_DATA(x))


PRIMITIVE STk_init__int()
{
	Wrapper<_int>::type = STk_new_CXXwrapper_id(
			Wrapper<_int>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_int,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_int);
	Tcl_InitHashTable(&Register<_int>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_intMethods(void);

PRIMITIVE STk_init_methods__int()
{
	genExtra_intMethods();
	return UNDEFINED;
}
// this file merely satisfies sccs in Make.*
