text:
/*  This file is automatically generated by dpp and should not normally
    be edited by hand.  */

#include "generics.h"

#ifdef	DPP_STRATEGY
#if	DPP_STRATEGY != 2
#error Incompatible DPP Strategies
#endif
#else
#error DPP_STRATEGY not set.
#endif

#ifdef	DPP_FASTWIDE
#if	DPP_FASTWIDE != 0
#error Incompatible DPP FastWide Status
#endif
#else
#error DPP_FASTWIDE not set.
#endif

#ifdef	__cplusplus
extern	"C"  {
#endif

object	Generic(gAccept);
object	Generic(gAdd);
object	Generic(gAddAfter);
object	Generic(gAddBTreeNode);
object	Generic(gAddBefore);
object	Generic(gAddBodyPart);
object	Generic(gAddDays);
object	Generic(gAddFirst);
object	Generic(gAddHeader);
object	Generic(gAddHours);
object	Generic(gAddInt);
object	Generic(gAddLast);
object	Generic(gAddMilliseconds);
object	Generic(gAddMinutes);
object	Generic(gAddMonths);
object	Generic(gAddSeconds);
object	Generic(gAddStr);
object	Generic(gAddToPool);
object	Generic(gAddValue);
object	Generic(gAddYears);
object	Generic(gAdvance);
object	Generic(gAlloc);
object	Generic(gAppend);
object	Generic(gAppendChild);
object	Generic(gApplyMask);
object	Generic(gArgs);
object	Generic(gArrayPointer);
object	Generic(gAttributes);
object	Generic(gBasicSize);
object	Generic(gBlockingGetkey);
object	Generic(gBufferSize);
object	Generic(gCalToJul);
object	Generic(gChangeCharAt);
object	Generic(gChangeCharValue);
object	Generic(gChangeDateTimeValues);
object	Generic(gChangeDateValue);
object	Generic(gChangeDoubleValue);
object	Generic(gChangeFixedName);
object	Generic(gChangeFunction);
object	Generic(gChangeIntKey);
object	Generic(gChangeKey);
object	Generic(gChangeLongValue);
object	Generic(gChangeName);
object	Generic(gChangeNext);
object	Generic(gChangePrevious);
object	Generic(gChangePriority);
object	Generic(gChangeRegisteredMemory);
object	Generic(gChangeShortValue);
object	Generic(gChangeStrValue);
object	Generic(gChangeStringKey);
object	Generic(gChangeTimeValue);
object	Generic(gChangeToken);
object	Generic(gChangeUShortValue);
object	Generic(gChangeValue);
object	Generic(gChangeValueWithInt);
object	Generic(gChangeValueWithObj);
object	Generic(gChangeValueWithStr);
object	Generic(gCharValue);
object	Generic(gCharValueAt);
object	Generic(gChild);
object	Generic(gCompare);
object	Generic(gCompareI);
object	Generic(gCompareN);
object	Generic(gCompareNI);
object	Generic(gCopy);
object	Generic(gCount);
object	Generic(gCreateAttribute);
object	Generic(gCreateCDATASection);
object	Generic(gCreateComment);
object	Generic(gCreateElement);
object	Generic(gCreateTextNode);
object	Generic(gCurMemUsed);
object	Generic(gDateTimeDifference);
object	Generic(gDateTimeValues);
object	Generic(gDateValue);
object	Generic(gDayName);
object	Generic(gDeepCopy);
object	Generic(gDeepDispose);
object	Generic(gDeepDisposeAllNodes);
object	Generic(gDeepDisposeFirst);
object	Generic(gDeepDisposeGroup);
object	Generic(gDeepDisposeInt);
object	Generic(gDeepDisposeLast);
object	Generic(gDeepDisposeObj);
object	Generic(gDeepDisposeStr);
object	Generic(gDefaultRestart);
object	Generic(gDeleteBTNode);
object	Generic(gDifference);
object	Generic(gDispose);
object	Generic(gDispose1);
object	Generic(gDisposeAllNodes);
object	Generic(gDisposeAllNodes1);
object	Generic(gDisposeAttribute);
object	Generic(gDisposeFirst);
object	Generic(gDisposeGlobalPool);
object	Generic(gDisposeGroup);
object	Generic(gDisposeInt);
object	Generic(gDisposeItem);
object	Generic(gDisposeLast);
object	Generic(gDisposeObj);
object	Generic(gDisposeObject);
object	Generic(gDisposePropertyList);
object	Generic(gDisposeStr);
object	Generic(gDoesNotImplement);
object	Generic(gDontCollect);
object	Generic(gDoubleValue);
object	Generic(gDrop);
object	Generic(gDumpMemoryDiff);
object	Generic(gDumpObjects);
object	Generic(gDumpObjectsDiff);
object	Generic(gDumpObjectsString);
object	Generic(gDumpXML);
object	Generic(gEndOfStream);
object	Generic(gEnterCriticalSection);
object	Generic(gEqual);
object	Generic(gError);
object	Generic(gException);
object	Generic(gFileHandle);
object	Generic(gFind);
object	Generic(gFindAdd);
object	Generic(gFindAddInt);
object	Generic(gFindAddStr);
object	Generic(gFindAddValue);
object	Generic(gFindBTNEQ);
object	Generic(gFindBTNFirst);
object	Generic(gFindBTNGE);
object	Generic(gFindBTNGT);
object	Generic(gFindBTNLE);
object	Generic(gFindBTNLT);
object	Generic(gFindBTNLast);
object	Generic(gFindChildNode);
object	Generic(gFindChildNodeWithText);
object	Generic(gFindClass);
object	Generic(gFindEQ);
object	Generic(gFindFirst);
object	Generic(gFindGE);
object	Generic(gFindGT);
object	Generic(gFindGeneric);
object	Generic(gFindInt);
object	Generic(gFindLE);
object	Generic(gFindLT);
object	Generic(gFindLast);
object	Generic(gFindMethod);
object	Generic(gFindMethodObject);
object	Generic(gFindNext);
object	Generic(gFindNextNode);
object	Generic(gFindNode);
object	Generic(gFindPrev);
object	Generic(gFindStr);
object	Generic(gFindValue);
object	Generic(gFindValueInt);
object	Generic(gFindValueStr);
object	Generic(gFirst);
object	Generic(gFirstAttribute);
object	Generic(gFixInvalidDate);
object	Generic(gFlush);
object	Generic(gFlushm);
object	Generic(gForAll);
object	Generic(gForceLineDirective);
object	Generic(gFormatChar);
object	Generic(gFormatDate);
object	Generic(gFormatDateTime);
object	Generic(gFormatNumber);
object	Generic(gFormatTime);
object	Generic(gFunction);
object	Generic(gGC);
object	Generic(gGCDispose);
object	Generic(gGetAll);
object	Generic(gGetAttribute);
object	Generic(gGetAttributeValue);
object	Generic(gGetBodyContent);
object	Generic(gGetBodyParts);
object	Generic(gGetBoundaryString);
object	Generic(gGetCharFromNode);
object	Generic(gGetCipher);
object	Generic(gGetContentType);
object	Generic(gGetErrorCode);
object	Generic(gGetErrorStr);
object	Generic(gGetFixedName);
object	Generic(gGetFloatFromNode);
object	Generic(gGetGenericPtr);
object	Generic(gGetHeader);
object	Generic(gGetHeaders);
object	Generic(gGetIntFromNode);
object	Generic(gGetMGName);
object	Generic(gGetName);
object	Generic(gGetParent);
object	Generic(gGetPeerCertificateIssuerName);
object	Generic(gGetPeerCertificateSubjectName);
object	Generic(gGetSessionInfo);
object	Generic(gGetStr);
object	Generic(gGetTotalBytesRead);
object	Generic(gGets);
object	Generic(gGroupRemove);
object	Generic(gHasInputArg);
object	Generic(gHash);
object	Generic(gHold);
object	Generic(gHours);
object	Generic(gHowManyBitsOfPeerPublicKey);
object	Generic(gIPAddress);
object	Generic(gIPAddressStr);
object	Generic(gIncNelm);
object	Generic(gIndex);
object	Generic(gIndexOrigin);
object	Generic(gInit);
object	Generic(gInitLink);
object	Generic(gInsertBefore);
object	Generic(gInsertObjAt);
object	Generic(gInstanceSize);
object	Generic(gIntKey);
object	Generic(gIntValue);
object	Generic(gInvalidObject);
object	Generic(gInvalidType);
object	Generic(gIota);
object	Generic(gIsKindOf);
object	Generic(gIsVarArg);
object	Generic(gJulToCal);
object	Generic(gJulian);
object	Generic(gJustifyCenter);
object	Generic(gJustifyLeft);
object	Generic(gJustifyRight);
object	Generic(gKey);
object	Generic(gKill);
object	Generic(gLast);
object	Generic(gLastArg);
object	Generic(gLeaveCriticalSection);
object	Generic(gLength);
object	Generic(gLineHasColon);
object	Generic(gLineNumber);
object	Generic(gList);
object	Generic(gLoadJavaClass);
object	Generic(gLoadMask);
object	Generic(gLock);
object	Generic(gLongValue);
object	Generic(gLookup);
object	Generic(gMakeServer);
object	Generic(gMarkMemoryBeginning);
object	Generic(gMarkObject);
object	Generic(gMarkRange);
object	Generic(gMarkingMethod);
object	Generic(gMaskFunction);
object	Generic(gMatch);
object	Generic(gMatchNoError);
object	Generic(gMaxAfterGC);
object	Generic(gMaxMemUsed);
object	Generic(gMilliseconds);
object	Generic(gMinutes);
object	Generic(gMode);
object	Generic(gMonthName);
object	Generic(gMoreHandles);
object	Generic(gMoveAfter);
object	Generic(gMoveBefore);
object	Generic(gMoveBeginning);
object	Generic(gMoveEnd);
object	Generic(gName);
object	Generic(gNew);
object	Generic(gNewArglist);
object	Generic(gNewArray);
object	Generic(gNewClass);
object	Generic(gNewDateTime);
object	Generic(gNewDocument);
object	Generic(gNewFindFile);
object	Generic(gNewGeneric);
object	Generic(gNewGlobalPool);
object	Generic(gNewGlobalPoolWithSize);
object	Generic(gNewMethod);
object	Generic(gNewMimeBodyPart);
object	Generic(gNewMultipartMime);
object	Generic(gNewNode);
object	Generic(gNewSemaphore);
object	Generic(gNewSetSeq);
object	Generic(gNewStdClass);
object	Generic(gNewThread);
object	Generic(gNewToken);
object	Generic(gNewWithChar);
object	Generic(gNewWithDouble);
object	Generic(gNewWithInt);
object	Generic(gNewWithIntObj);
object	Generic(gNewWithLong);
object	Generic(gNewWithObj);
object	Generic(gNewWithObjObj);
object	Generic(gNewWithPtr);
object	Generic(gNewWithStr);
object	Generic(gNewWithStrInt);
object	Generic(gNewWithStrObj);
object	Generic(gNewWithStrStr);
object	Generic(gNewWithStream);
object	Generic(gNewWithUnsigned);
object	Generic(gNext);
object	Generic(gNextFile);
object	Generic(gNextToken);
object	Generic(gNow);
object	Generic(gNth);
object	Generic(gNumbGC);
object	Generic(gNumbPieces);
object	Generic(gObjectChecking);
object	Generic(gObjectSerialNumber);
object	Generic(gOpenFile);
object	Generic(gOpenLowFile);
object	Generic(gOpenStream2);
object	Generic(gOpenTempFile);
object	Generic(gParameters);
object	Generic(gParent);
object	Generic(gParseFile);
object	Generic(gParseMultipartFromString);
object	Generic(gParseString);
object	Generic(gPiece);
object	Generic(gPointerValue);
object	Generic(gPop);
object	Generic(gPopulateStringFromNode);
object	Generic(gPosition);
object	Generic(gPrevious);
object	Generic(gPrint);
object	Generic(gPrintArgs);
object	Generic(gPrintFixedArgs);
object	Generic(gPrintLength);
object	Generic(gPrintMethArgs);
object	Generic(gPrintValue);
object	Generic(gPrintVars);
object	Generic(gPriority);
object	Generic(gProcess);
object	Generic(gPropertyGet);
object	Generic(gPropertyPut);
object	Generic(gPropertyRemove);
object	Generic(gPropertySetAutoDispose);
object	Generic(gPrototype);
object	Generic(gProxyConnect);
object	Generic(gPush);
object	Generic(gPut);
object	Generic(gPutc);
object	Generic(gPutm);
object	Generic(gPuts);
object	Generic(gRank);
object	Generic(gRead);
object	Generic(gReadInt32);
object	Generic(gRecvFile);
object	Generic(gRegisterMemory);
object	Generic(gRelease);
object	Generic(gReleaseSemaphore);
object	Generic(gRemove);
object	Generic(gRemoveAttribute);
object	Generic(gRemoveFirst);
object	Generic(gRemoveFromPool);
object	Generic(gRemoveInt);
object	Generic(gRemoveLast);
object	Generic(gRemoveMask);
object	Generic(gRemoveNode);
object	Generic(gRemoveObj);
object	Generic(gRemoveRegisteredMemory);
object	Generic(gRemoveStr);
object	Generic(gRemoveWaits);
object	Generic(gResize);
object	Generic(gResizeMethodCache);
object	Generic(gRetreat);
object	Generic(gReturnType);
object	Generic(gRoom);
object	Generic(gRound);
object	Generic(gSLineDirective);
object	Generic(gSaveXML);
object	Generic(gSeconds);
object	Generic(gSeek);
object	Generic(gSendFile);
object	Generic(gSendStr);
object	Generic(gSequence);
object	Generic(gSequenceLinks);
object	Generic(gServerSocketConnect);
object	Generic(gSetArgs);
object	Generic(gSetAttribute);
object	Generic(gSetErrorFunction);
object	Generic(gSetFunction);
object	Generic(gSetMaskFiller);
object	Generic(gSetMemoryBufferArea);
object	Generic(gSetMoreHandles);
object	Generic(gSetNodeName);
object	Generic(gSetNodeValue);
object	Generic(gSetOSVars);
object	Generic(gSetPropertyList);
object	Generic(gSetTempSubDir);
object	Generic(gSetTopNode);
object	Generic(gShape);
object	Generic(gShortValue);
object	Generic(gShouldNotImplement);
object	Generic(gSignal);
object	Generic(gSize);
object	Generic(gSocketConnect);
object	Generic(gSpace);
object	Generic(gStackAlloc);
object	Generic(gState);
object	Generic(gStringKey);
object	Generic(gStringRep);
object	Generic(gStringRepValue);
object	Generic(gStringToXML);
object	Generic(gStringValue);
object	Generic(gStripCenter);
object	Generic(gStripLeft);
object	Generic(gStripRight);
object	Generic(gSubClasses);
object	Generic(gSubString);
object	Generic(gSubclassResponsibility);
object	Generic(gSuperClasses);
object	Generic(gTLineDirective);
object	Generic(gTake);
object	Generic(gTimeDifference);
object	Generic(gTimeStringRepValue);
object	Generic(gTimeValue);
object	Generic(gTimedRead);
object	Generic(gTimedReadMS);
object	Generic(gTimedWrite);
object	Generic(gToLower);
object	Generic(gToUpper);
object	Generic(gToday);
object	Generic(gToken);
object	Generic(gTrace);
object	Generic(gTracePrint);
object	Generic(gTruncate);
object	Generic(gType);
object	Generic(gUnLock);
object	Generic(gUnsignedShortValue);
object	Generic(gUpdateLength);
object	Generic(gUseStream);
object	Generic(gUseVars);
object	Generic(gValidDate);
object	Generic(gValidDateTime);
object	Generic(gValidTime);
object	Generic(gValue);
object	Generic(gVarArg);
object	Generic(gWaitFor);
object	Generic(gWaitSemaphore);
object	Generic(gWrite);
object	Generic(gWriteInt32);
object	Generic(gWriteTime);
object	Generic(gXMLToString);
object	Generic(gXPath);
object	Generic(vBitValue);
object	Generic(vBuild);
object	Generic(vChangeBitValue);
object	Generic(vChangeCharValue);
object	Generic(vChangeDoubleValue);
object	Generic(vChangeLongValue);
object	Generic(vChangeShortValue);
object	Generic(vChangeUShortValue);
object	Generic(vChangeValue);
object	Generic(vCharValue);
object	Generic(vDoubleValue);
object	Generic(vError);
object	Generic(vGetValues);
object	Generic(vLongValue);
object	Generic(vMakeList);
object	Generic(vNew);
object	Generic(vPointerValue);
object	Generic(vPrintf);
object	Generic(vReshape);
object	Generic(vShortValue);
object	Generic(vSprintf);
object	Generic(vUnsignedShortValue);
object	Generic(vValue);

static	objrtn	_gAccept(object self)
{
	return (*(gAccept_t)_FindMethod(self, Generic(gAccept)))(self);
}

static	objrtn	_gAdd(object self, object luk)
{
	return (*(gAdd_t)_FindMethod(self, Generic(gAdd)))(self, luk);
}

static	objrtn	_gAddAfter(object self, object lnk)
{
	return (*(gAddAfter_t)_FindMethod(self, Generic(gAddAfter)))(self, lnk);
}

static	objrtn	_gAddBTreeNode(object self, ifun cfun, object key, object data, int replace, int *replaced, object prev, object *old)
{
	return (*(gAddBTreeNode_t)_FindMethod(self, Generic(gAddBTreeNode)))(self, cfun, key, data, replace, replaced, prev, old);
}

static	objrtn	_gAddBefore(object self, object lnk)
{
	return (*(gAddBefore_t)_FindMethod(self, Generic(gAddBefore)))(self, lnk);
}

static	objrtn	_gAddBodyPart(object self, object bodyPart)
{
	return (*(gAddBodyPart_t)_FindMethod(self, Generic(gAddBodyPart)))(self, bodyPart);
}

static	objrtn	_gAddDays(object self, long days)
{
	return (*(gAddDays_t)_FindMethod(self, Generic(gAddDays)))(self, days);
}

static	objrtn	_gAddFirst(object self, object lnk)
{
	return (*(gAddFirst_t)_FindMethod(self, Generic(gAddFirst)))(self, lnk);
}

static	objrtn	_gAddHeader(object self, char *name, char *value)
{
	return (*(gAddHeader_t)_FindMethod(self, Generic(gAddHeader)))(self, name, value);
}

static	objrtn	_gAddHours(object self, long h)
{
	return (*(gAddHours_t)_FindMethod(self, Generic(gAddHours)))(self, h);
}

static	objrtn	_gAddInt(object self, int key, object value)
{
	return (*(gAddInt_t)_FindMethod(self, Generic(gAddInt)))(self, key, value);
}

static	objrtn	_gAddLast(object self, object lnk)
{
	return (*(gAddLast_t)_FindMethod(self, Generic(gAddLast)))(self, lnk);
}

static	objrtn	_gAddMilliseconds(object self, long l)
{
	return (*(gAddMilliseconds_t)_FindMethod(self, Generic(gAddMilliseconds)))(self, l);
}

static	objrtn	_gAddMinutes(object self, long m)
{
	return (*(gAddMinutes_t)_FindMethod(self, Generic(gAddMinutes)))(self, m);
}

static	objrtn	_gAddMonths(object self, int months)
{
	return (*(gAddMonths_t)_FindMethod(self, Generic(gAddMonths)))(self, months);
}

static	objrtn	_gAddSeconds(object self, long s)
{
	return (*(gAddSeconds_t)_FindMethod(self, Generic(gAddSeconds)))(self, s);
}

static	objrtn	_gAddStr(object self, char *key, object value)
{
	return (*(gAddStr_t)_FindMethod(self, Generic(gAddStr)))(self, key, value);
}

static	objrtn	_gAddToPool(object self, int deepFlag, object obj)
{
	return (*(gAddToPool_t)_FindMethod(self, Generic(gAddToPool)))(self, deepFlag, obj);
}

static	objrtn	_gAddValue(object self, object key, object value)
{
	return (*(gAddValue_t)_FindMethod(self, Generic(gAddValue)))(self, key, value);
}

static	objrtn	_gAddYears(object self, int years)
{
	return (*(gAddYears_t)_FindMethod(self, Generic(gAddYears)))(self, years);
}

static	long	_gAdvance(object self, long n)
{
	return (*(gAdvance_t)_FindMethod(self, Generic(gAdvance)))(self, n);
}

static	objrtn	_gAlloc(object self)
{
	return (*(gAlloc_t)_FindMethod(self, Generic(gAlloc)))(self);
}

static	objrtn	_gAppend(object self, object obj)
{
	return (*(gAppend_t)_FindMethod(self, Generic(gAppend)))(self, obj);
}

static	objrtn	_gAppendChild(object self, object node)
{
	return (*(gAppendChild_t)_FindMethod(self, Generic(gAppendChild)))(self, node);
}

static	objrtn	_gApplyMask(object self, char *inmask, char *intext)
{
	return (*(gApplyMask_t)_FindMethod(self, Generic(gApplyMask)))(self, inmask, intext);
}

static	objrtn	_gArgs(object self)
{
	return (*(gArgs_t)_FindMethod(self, Generic(gArgs)))(self);
}

static	void *	_gArrayPointer(object self)
{
	return (*(gArrayPointer_t)_FindMethod(self, Generic(gArrayPointer)))(self);
}

static	unsigned	_gAttributes(object self)
{
	return (*(gAttributes_t)_FindMethod(self, Generic(gAttributes)))(self);
}

static	int	_gBasicSize(object self)
{
	return (*(gBasicSize_t)_FindMethod(self, Generic(gBasicSize)))(self);
}

static	int	_gBlockingGetkey(object self)
{
	return (*(gBlockingGetkey_t)_FindMethod(self, Generic(gBlockingGetkey)))(self);
}

static	int	_gBufferSize(object self)
{
	return (*(gBufferSize_t)_FindMethod(self, Generic(gBufferSize)))(self);
}

static	long	_gCalToJul(object self, long dt)
{
	return (*(gCalToJul_t)_FindMethod(self, Generic(gCalToJul)))(self, dt);
}

static	objrtn	_gChangeCharAt(object self, int i, int c)
{
	return (*(gChangeCharAt_t)_FindMethod(self, Generic(gChangeCharAt)))(self, i, c);
}

static	objrtn	_gChangeCharValue(object self, int val)
{
	return (*(gChangeCharValue_t)_FindMethod(self, Generic(gChangeCharValue)))(self, val);
}

static	objrtn	_gChangeDateTimeValues(object self, long dt, long tm)
{
	return (*(gChangeDateTimeValues_t)_FindMethod(self, Generic(gChangeDateTimeValues)))(self, dt, tm);
}

static	objrtn	_gChangeDateValue(object self, long dt)
{
	return (*(gChangeDateValue_t)_FindMethod(self, Generic(gChangeDateValue)))(self, dt);
}

static	objrtn	_gChangeDoubleValue(object self, double val)
{
	return (*(gChangeDoubleValue_t)_FindMethod(self, Generic(gChangeDoubleValue)))(self, val);
}

static	objrtn	_gChangeFixedName(object self, char *nm)
{
	return (*(gChangeFixedName_t)_FindMethod(self, Generic(gChangeFixedName)))(self, nm);
}

static	ofun	_gChangeFunction(object self, ofun fun)
{
	return (*(gChangeFunction_t)_FindMethod(self, Generic(gChangeFunction)))(self, fun);
}

static	objrtn	_gChangeIntKey(object self, int key)
{
	return (*(gChangeIntKey_t)_FindMethod(self, Generic(gChangeIntKey)))(self, key);
}

static	objrtn	_gChangeKey(object self, object key)
{
	return (*(gChangeKey_t)_FindMethod(self, Generic(gChangeKey)))(self, key);
}

static	objrtn	_gChangeLongValue(object self, long val)
{
	return (*(gChangeLongValue_t)_FindMethod(self, Generic(gChangeLongValue)))(self, val);
}

static	objrtn	_gChangeName(object self, char *nm)
{
	return (*(gChangeName_t)_FindMethod(self, Generic(gChangeName)))(self, nm);
}

static	objrtn	_gChangeNext(object self, object next)
{
	return (*(gChangeNext_t)_FindMethod(self, Generic(gChangeNext)))(self, next);
}

static	objrtn	_gChangePrevious(object self, object prev)
{
	return (*(gChangePrevious_t)_FindMethod(self, Generic(gChangePrevious)))(self, prev);
}

static	objrtn	_gChangePriority(object self, int p)
{
	return (*(gChangePriority_t)_FindMethod(self, Generic(gChangePriority)))(self, p);
}

static	void *	_gChangeRegisteredMemory(object self, void *pp, void *beg, long size)
{
	return (*(gChangeRegisteredMemory_t)_FindMethod(self, Generic(gChangeRegisteredMemory)))(self, pp, beg, size);
}

static	objrtn	_gChangeShortValue(object self, int val)
{
	return (*(gChangeShortValue_t)_FindMethod(self, Generic(gChangeShortValue)))(self, val);
}

static	objrtn	_gChangeStrValue(object self, char *str)
{
	return (*(gChangeStrValue_t)_FindMethod(self, Generic(gChangeStrValue)))(self, str);
}

static	objrtn	_gChangeStringKey(object self, char *key)
{
	return (*(gChangeStringKey_t)_FindMethod(self, Generic(gChangeStringKey)))(self, key);
}

static	objrtn	_gChangeTimeValue(object self, long val)
{
	return (*(gChangeTimeValue_t)_FindMethod(self, Generic(gChangeTimeValue)))(self, val);
}

static	objrtn	_gChangeToken(object self, char *str)
{
	return (*(gChangeToken_t)_FindMethod(self, Generic(gChangeToken)))(self, str);
}

static	objrtn	_gChangeUShortValue(object self, unsigned val)
{
	return (*(gChangeUShortValue_t)_FindMethod(self, Generic(gChangeUShortValue)))(self, val);
}

static	objrtn	_gChangeValue(object self, object value)
{
	return (*(gChangeValue_t)_FindMethod(self, Generic(gChangeValue)))(self, value);
}

static	objrtn	_gChangeValueWithInt(object self, int key, object val)
{
	return (*(gChangeValueWithInt_t)_FindMethod(self, Generic(gChangeValueWithInt)))(self, key, val);
}

static	objrtn	_gChangeValueWithObj(object self, object key, object val)
{
	return (*(gChangeValueWithObj_t)_FindMethod(self, Generic(gChangeValueWithObj)))(self, key, val);
}

static	objrtn	_gChangeValueWithStr(object self, char *key, object val)
{
	return (*(gChangeValueWithStr_t)_FindMethod(self, Generic(gChangeValueWithStr)))(self, key, val);
}

static	char	_gCharValue(object self)
{
	return (*(gCharValue_t)_FindMethod(self, Generic(gCharValue)))(self);
}

static	char	_gCharValueAt(object self, int i)
{
	return (*(gCharValueAt_t)_FindMethod(self, Generic(gCharValueAt)))(self, i);
}

static	objrtn	_gChild(object self)
{
	return (*(gChild_t)_FindMethod(self, Generic(gChild)))(self);
}

static	int	_gCompare(object self, object obj2)
{
	return (*(gCompare_t)_FindMethod(self, Generic(gCompare)))(self, obj2);
}

static	int	_gCompareI(object self, object obj)
{
	return (*(gCompareI_t)_FindMethod(self, Generic(gCompareI)))(self, obj);
}

static	int	_gCompareN(object self, object obj, int n)
{
	return (*(gCompareN_t)_FindMethod(self, Generic(gCompareN)))(self, obj, n);
}

static	int	_gCompareNI(object self, object obj, int n)
{
	return (*(gCompareNI_t)_FindMethod(self, Generic(gCompareNI)))(self, obj, n);
}

static	objrtn	_gCopy(object self)
{
	return (*(gCopy_t)_FindMethod(self, Generic(gCopy)))(self);
}

static	int	_gCount(object self)
{
	return (*(gCount_t)_FindMethod(self, Generic(gCount)))(self);
}

static	objrtn	_gCreateAttribute(object self, char *name, char *value)
{
	return (*(gCreateAttribute_t)_FindMethod(self, Generic(gCreateAttribute)))(self, name, value);
}

static	objrtn	_gCreateCDATASection(object self, char *text)
{
	return (*(gCreateCDATASection_t)_FindMethod(self, Generic(gCreateCDATASection)))(self, text);
}

static	objrtn	_gCreateComment(object self, char *text)
{
	return (*(gCreateComment_t)_FindMethod(self, Generic(gCreateComment)))(self, text);
}

static	objrtn	_gCreateElement(object self, char *name)
{
	return (*(gCreateElement_t)_FindMethod(self, Generic(gCreateElement)))(self, name);
}

static	objrtn	_gCreateTextNode(object self, char *text)
{
	return (*(gCreateTextNode_t)_FindMethod(self, Generic(gCreateTextNode)))(self, text);
}

static	long	_gCurMemUsed(object self)
{
	return (*(gCurMemUsed_t)_FindMethod(self, Generic(gCurMemUsed)))(self);
}

static	objrtn	_gDateTimeDifference(object self, object dt, long *ddr, long *tdr)
{
	return (*(gDateTimeDifference_t)_FindMethod(self, Generic(gDateTimeDifference)))(self, dt, ddr, tdr);
}

static	objrtn	_gDateTimeValues(object self, long *dt, long *tm)
{
	return (*(gDateTimeValues_t)_FindMethod(self, Generic(gDateTimeValues)))(self, dt, tm);
}

static	long	_gDateValue(object self)
{
	return (*(gDateValue_t)_FindMethod(self, Generic(gDateValue)))(self);
}

static	objrtn	_gDayName(object self)
{
	return (*(gDayName_t)_FindMethod(self, Generic(gDayName)))(self);
}

static	objrtn	_gDeepCopy(object self)
{
	return (*(gDeepCopy_t)_FindMethod(self, Generic(gDeepCopy)))(self);
}

static	objrtn	_gDeepDispose(object self)
{
	return (*(gDeepDispose_t)_FindMethod(self, Generic(gDeepDispose)))(self);
}

static	objrtn	_gDeepDisposeAllNodes(object self)
{
	return (*(gDeepDisposeAllNodes_t)_FindMethod(self, Generic(gDeepDisposeAllNodes)))(self);
}

static	objrtn	_gDeepDisposeFirst(object self)
{
	return (*(gDeepDisposeFirst_t)_FindMethod(self, Generic(gDeepDisposeFirst)))(self);
}

static	objrtn	_gDeepDisposeGroup(object self, int (*fun)())
{
	return (*(gDeepDisposeGroup_t)_FindMethod(self, Generic(gDeepDisposeGroup)))(self, fun);
}

static	objrtn	_gDeepDisposeInt(object self, int key)
{
	return (*(gDeepDisposeInt_t)_FindMethod(self, Generic(gDeepDisposeInt)))(self, key);
}

static	objrtn	_gDeepDisposeLast(object self)
{
	return (*(gDeepDisposeLast_t)_FindMethod(self, Generic(gDeepDisposeLast)))(self);
}

static	objrtn	_gDeepDisposeObj(object self, object luk)
{
	return (*(gDeepDisposeObj_t)_FindMethod(self, Generic(gDeepDisposeObj)))(self, luk);
}

static	objrtn	_gDeepDisposeStr(object self, char *key)
{
	return (*(gDeepDisposeStr_t)_FindMethod(self, Generic(gDeepDisposeStr)))(self, key);
}

static	objrtn	_gDefaultRestart(object self)
{
	return (*(gDefaultRestart_t)_FindMethod(self, Generic(gDefaultRestart)))(self);
}

static	objrtn	_gDeleteBTNode(object self, ifun cfun, object key, int deep, object prev)
{
	return (*(gDeleteBTNode_t)_FindMethod(self, Generic(gDeleteBTNode)))(self, cfun, key, deep, prev);
}

static	long	_gDifference(object self, object dt)
{
	return (*(gDifference_t)_FindMethod(self, Generic(gDifference)))(self, dt);
}

static	objrtn	_gDispose(object self)
{
	return (*(gDispose_t)_FindMethod(self, Generic(gDispose)))(self);
}

static	objrtn	_gDispose1(object self)
{
	return (*(gDispose1_t)_FindMethod(self, Generic(gDispose1)))(self);
}

static	objrtn	_gDisposeAllNodes(object self)
{
	return (*(gDisposeAllNodes_t)_FindMethod(self, Generic(gDisposeAllNodes)))(self);
}

static	objrtn	_gDisposeAllNodes1(object self)
{
	return (*(gDisposeAllNodes1_t)_FindMethod(self, Generic(gDisposeAllNodes1)))(self);
}

static	objrtn	_gDisposeAttribute(object self, char *name)
{
	return (*(gDisposeAttribute_t)_FindMethod(self, Generic(gDisposeAttribute)))(self, name);
}

static	objrtn	_gDisposeFirst(object self)
{
	return (*(gDisposeFirst_t)_FindMethod(self, Generic(gDisposeFirst)))(self);
}

static	objrtn	_gDisposeGlobalPool(object self)
{
	return (*(gDisposeGlobalPool_t)_FindMethod(self, Generic(gDisposeGlobalPool)))(self);
}

static	objrtn	_gDisposeGroup(object self, int (*fun)())
{
	return (*(gDisposeGroup_t)_FindMethod(self, Generic(gDisposeGroup)))(self, fun);
}

static	objrtn	_gDisposeInt(object self, int key)
{
	return (*(gDisposeInt_t)_FindMethod(self, Generic(gDisposeInt)))(self, key);
}

static	objrtn	_gDisposeItem(object self)
{
	return (*(gDisposeItem_t)_FindMethod(self, Generic(gDisposeItem)))(self);
}

static	objrtn	_gDisposeLast(object self)
{
	return (*(gDisposeLast_t)_FindMethod(self, Generic(gDisposeLast)))(self);
}

static	objrtn	_gDisposeObj(object self, object luk)
{
	return (*(gDisposeObj_t)_FindMethod(self, Generic(gDisposeObj)))(self, luk);
}

static	objrtn	_gDisposeObject(object self, object obj)
{
	return (*(gDisposeObject_t)_FindMethod(self, Generic(gDisposeObject)))(self, obj);
}

static	objrtn	_gDisposePropertyList(object self)
{
	return (*(gDisposePropertyList_t)_FindMethod(self, Generic(gDisposePropertyList)))(self);
}

static	objrtn	_gDisposeStr(object self, char *key)
{
	return (*(gDisposeStr_t)_FindMethod(self, Generic(gDisposeStr)))(self, key);
}

static	void	_gDoesNotImplement(object self, object gen)
{
	 (*(gDoesNotImplement_t)_FindMethod(self, Generic(gDoesNotImplement)))(self, gen);
}

static	objrtn	_gDontCollect(object self)
{
	return (*(gDontCollect_t)_FindMethod(self, Generic(gDontCollect)))(self);
}

static	double	_gDoubleValue(object self)
{
	return (*(gDoubleValue_t)_FindMethod(self, Generic(gDoubleValue)))(self);
}

static	objrtn	_gDrop(object self, int n)
{
	return (*(gDrop_t)_FindMethod(self, Generic(gDrop)))(self, n);
}

static	objrtn	_gDumpMemoryDiff(object self, object d1, char *fname)
{
	return (*(gDumpMemoryDiff_t)_FindMethod(self, Generic(gDumpMemoryDiff)))(self, d1, fname);
}

static	objrtn	_gDumpObjects(object self, char *file, int type)
{
	return (*(gDumpObjects_t)_FindMethod(self, Generic(gDumpObjects)))(self, file, type);
}

static	objrtn	_gDumpObjectsDiff(object self, object sd1, object sd2)
{
	return (*(gDumpObjectsDiff_t)_FindMethod(self, Generic(gDumpObjectsDiff)))(self, sd1, sd2);
}

static	objrtn	_gDumpObjectsString(object self, int type)
{
	return (*(gDumpObjectsString_t)_FindMethod(self, Generic(gDumpObjectsString)))(self, type);
}

static	objrtn	_gDumpXML(object self, int level, object stm, int next)
{
	return (*(gDumpXML_t)_FindMethod(self, Generic(gDumpXML)))(self, level, stm, next);
}

static	int	_gEndOfStream(object self)
{
	return (*(gEndOfStream_t)_FindMethod(self, Generic(gEndOfStream)))(self);
}

static	objrtn	_gEnterCriticalSection(object self)
{
	return (*(gEnterCriticalSection_t)_FindMethod(self, Generic(gEnterCriticalSection)))(self);
}

static	int	_gEqual(object self, object obj2)
{
	return (*(gEqual_t)_FindMethod(self, Generic(gEqual)))(self, obj2);
}

static	objrtn	_gError(object self, char *msg)
{
	return (*(gError_t)_FindMethod(self, Generic(gError)))(self, msg);
}

static	objrtn	_gException(object self)
{
	return (*(gException_t)_FindMethod(self, Generic(gException)))(self);
}

static	int	_gFileHandle(object self)
{
	return (*(gFileHandle_t)_FindMethod(self, Generic(gFileHandle)))(self);
}

static	objrtn	_gFind(object self, object luk)
{
	return (*(gFind_t)_FindMethod(self, Generic(gFind)))(self, luk);
}

static	objrtn	_gFindAdd(object self, object luk)
{
	return (*(gFindAdd_t)_FindMethod(self, Generic(gFindAdd)))(self, luk);
}

static	objrtn	_gFindAddInt(object self, int key, object value)
{
	return (*(gFindAddInt_t)_FindMethod(self, Generic(gFindAddInt)))(self, key, value);
}

static	objrtn	_gFindAddStr(object self, char *key, object value)
{
	return (*(gFindAddStr_t)_FindMethod(self, Generic(gFindAddStr)))(self, key, value);
}

static	objrtn	_gFindAddValue(object self, object key, object value)
{
	return (*(gFindAddValue_t)_FindMethod(self, Generic(gFindAddValue)))(self, key, value);
}

static	objrtn	_gFindBTNEQ(object self, ifun cfun, object key, object *foundKey)
{
	return (*(gFindBTNEQ_t)_FindMethod(self, Generic(gFindBTNEQ)))(self, cfun, key, foundKey);
}

static	objrtn	_gFindBTNFirst(object self, ifun cfun, object *foundKey)
{
	return (*(gFindBTNFirst_t)_FindMethod(self, Generic(gFindBTNFirst)))(self, cfun, foundKey);
}

static	objrtn	_gFindBTNGE(object self, ifun cfun, object key, object *foundKey)
{
	return (*(gFindBTNGE_t)_FindMethod(self, Generic(gFindBTNGE)))(self, cfun, key, foundKey);
}

static	objrtn	_gFindBTNGT(object self, ifun cfun, object key, object *foundKey)
{
	return (*(gFindBTNGT_t)_FindMethod(self, Generic(gFindBTNGT)))(self, cfun, key, foundKey);
}

static	objrtn	_gFindBTNLE(object self, ifun cfun, object key, object *foundKey)
{
	return (*(gFindBTNLE_t)_FindMethod(self, Generic(gFindBTNLE)))(self, cfun, key, foundKey);
}

static	objrtn	_gFindBTNLT(object self, ifun cfun, object key, object *foundKey)
{
	return (*(gFindBTNLT_t)_FindMethod(self, Generic(gFindBTNLT)))(self, cfun, key, foundKey);
}

static	objrtn	_gFindBTNLast(object self, ifun cfun, object *foundKey)
{
	return (*(gFindBTNLast_t)_FindMethod(self, Generic(gFindBTNLast)))(self, cfun, foundKey);
}

static	objrtn	_gFindChildNode(object self, char *name)
{
	return (*(gFindChildNode_t)_FindMethod(self, Generic(gFindChildNode)))(self, name);
}

static	objrtn	_gFindChildNodeWithText(object self, char *name, char *txt)
{
	return (*(gFindChildNodeWithText_t)_FindMethod(self, Generic(gFindChildNodeWithText)))(self, name, txt);
}

static	objrtn	_gFindClass(object self, char *name)
{
	return (*(gFindClass_t)_FindMethod(self, Generic(gFindClass)))(self, name);
}

static	objrtn	_gFindEQ(object self, object key, object *foundKey)
{
	return (*(gFindEQ_t)_FindMethod(self, Generic(gFindEQ)))(self, key, foundKey);
}

static	objrtn	_gFindFirst(object self, object *foundKey)
{
	return (*(gFindFirst_t)_FindMethod(self, Generic(gFindFirst)))(self, foundKey);
}

static	objrtn	_gFindGE(object self, object key, object *foundKey)
{
	return (*(gFindGE_t)_FindMethod(self, Generic(gFindGE)))(self, key, foundKey);
}

static	objrtn	_gFindGT(object self, object key, object *foundKey)
{
	return (*(gFindGT_t)_FindMethod(self, Generic(gFindGT)))(self, key, foundKey);
}

static	objrtn	_gFindGeneric(object self, char *nam)
{
	return (*(gFindGeneric_t)_FindMethod(self, Generic(gFindGeneric)))(self, nam);
}

static	objrtn	_gFindInt(object self, int key)
{
	return (*(gFindInt_t)_FindMethod(self, Generic(gFindInt)))(self, key);
}

static	objrtn	_gFindLE(object self, object key, object *foundKey)
{
	return (*(gFindLE_t)_FindMethod(self, Generic(gFindLE)))(self, key, foundKey);
}

static	objrtn	_gFindLT(object self, object key, object *foundKey)
{
	return (*(gFindLT_t)_FindMethod(self, Generic(gFindLT)))(self, key, foundKey);
}

static	objrtn	_gFindLast(object self, object *foundKey)
{
	return (*(gFindLast_t)_FindMethod(self, Generic(gFindLast)))(self, foundKey);
}

static	ofun	_gFindMethod(object self, object generic, int lev)
{
	return (*(gFindMethod_t)_FindMethod(self, Generic(gFindMethod)))(self, generic, lev);
}

static	objrtn	_gFindMethodObject(object self, object generic, int lev)
{
	return (*(gFindMethodObject_t)_FindMethod(self, Generic(gFindMethodObject)))(self, generic, lev);
}

static	objrtn	_gFindNext(object self, object *foundKey)
{
	return (*(gFindNext_t)_FindMethod(self, Generic(gFindNext)))(self, foundKey);
}

static	objrtn	_gFindNextNode(object self, char *name)
{
	return (*(gFindNextNode_t)_FindMethod(self, Generic(gFindNextNode)))(self, name);
}

static	objrtn	_gFindNode(object self, char *name)
{
	return (*(gFindNode_t)_FindMethod(self, Generic(gFindNode)))(self, name);
}

static	objrtn	_gFindPrev(object self, object *foundKey)
{
	return (*(gFindPrev_t)_FindMethod(self, Generic(gFindPrev)))(self, foundKey);
}

static	objrtn	_gFindStr(object self, char *key)
{
	return (*(gFindStr_t)_FindMethod(self, Generic(gFindStr)))(self, key);
}

static	objrtn	_gFindValue(object self, object key)
{
	return (*(gFindValue_t)_FindMethod(self, Generic(gFindValue)))(self, key);
}

static	objrtn	_gFindValueInt(object self, int key)
{
	return (*(gFindValueInt_t)_FindMethod(self, Generic(gFindValueInt)))(self, key);
}

static	objrtn	_gFindValueStr(object self, char *key)
{
	return (*(gFindValueStr_t)_FindMethod(self, Generic(gFindValueStr)))(self, key);
}

static	objrtn	_gFirst(object self)
{
	return (*(gFirst_t)_FindMethod(self, Generic(gFirst)))(self);
}

static	objrtn	_gFirstAttribute(object self)
{
	return (*(gFirstAttribute_t)_FindMethod(self, Generic(gFirstAttribute)))(self);
}

static	int	_gFixInvalidDate(object self, int mode)
{
	return (*(gFixInvalidDate_t)_FindMethod(self, Generic(gFixInvalidDate)))(self, mode);
}

static	int	_gFlush(object self)
{
	return (*(gFlush_t)_FindMethod(self, Generic(gFlush)))(self);
}

static	objrtn	_gFlushm(object self)
{
	return (*(gFlushm_t)_FindMethod(self, Generic(gFlushm)))(self);
}

static	objrtn	_gForAll(object self, object (*fun)())
{
	return (*(gForAll_t)_FindMethod(self, Generic(gForAll)))(self, fun);
}

static	objrtn	_gForceLineDirective(object self)
{
	return (*(gForceLineDirective_t)_FindMethod(self, Generic(gForceLineDirective)))(self);
}

static	objrtn	_gFormatChar(object self)
{
	return (*(gFormatChar_t)_FindMethod(self, Generic(gFormatChar)))(self);
}

static	objrtn	_gFormatDate(object self, char *msk)
{
	return (*(gFormatDate_t)_FindMethod(self, Generic(gFormatDate)))(self, msk);
}

static	objrtn	_gFormatDateTime(object self, char *dtbuf, char *tmbuf)
{
	return (*(gFormatDateTime_t)_FindMethod(self, Generic(gFormatDateTime)))(self, dtbuf, tmbuf);
}

static	objrtn	_gFormatNumber(object self, char *msk, int wth, int dp)
{
	return (*(gFormatNumber_t)_FindMethod(self, Generic(gFormatNumber)))(self, msk, wth, dp);
}

static	objrtn	_gFormatTime(object self, char *msk)
{
	return (*(gFormatTime_t)_FindMethod(self, Generic(gFormatTime)))(self, msk);
}

static	ofun	_gFunction(object self)
{
	return (*(gFunction_t)_FindMethod(self, Generic(gFunction)))(self);
}

static	objrtn	_gGC(object self)
{
	return (*(gGC_t)_FindMethod(self, Generic(gGC)))(self);
}

static	objrtn	_gGCDispose(object self)
{
	return (*(gGCDispose_t)_FindMethod(self, Generic(gGCDispose)))(self);
}

static	objrtn	_gGetAll(object self)
{
	return (*(gGetAll_t)_FindMethod(self, Generic(gGetAll)))(self);
}

static	objrtn	_gGetAttribute(object self, char *name)
{
	return (*(gGetAttribute_t)_FindMethod(self, Generic(gGetAttribute)))(self, name);
}

static	char *	_gGetAttributeValue(object self, char *name)
{
	return (*(gGetAttributeValue_t)_FindMethod(self, Generic(gGetAttributeValue)))(self, name);
}

static	char *	_gGetBodyContent(object self)
{
	return (*(gGetBodyContent_t)_FindMethod(self, Generic(gGetBodyContent)))(self);
}

static	objrtn	_gGetBodyParts(object self)
{
	return (*(gGetBodyParts_t)_FindMethod(self, Generic(gGetBodyParts)))(self);
}

static	char *	_gGetBoundaryString(object self)
{
	return (*(gGetBoundaryString_t)_FindMethod(self, Generic(gGetBoundaryString)))(self);
}

static	char	_gGetCharFromNode(object self, char *node)
{
	return (*(gGetCharFromNode_t)_FindMethod(self, Generic(gGetCharFromNode)))(self, node);
}

static	char *	_gGetCipher(object self)
{
	return (*(gGetCipher_t)_FindMethod(self, Generic(gGetCipher)))(self);
}

static	char *	_gGetContentType(object self)
{
	return (*(gGetContentType_t)_FindMethod(self, Generic(gGetContentType)))(self);
}

static	int	_gGetErrorCode(object self)
{
	return (*(gGetErrorCode_t)_FindMethod(self, Generic(gGetErrorCode)))(self);
}

static	char *	_gGetErrorStr(object self)
{
	return (*(gGetErrorStr_t)_FindMethod(self, Generic(gGetErrorStr)))(self);
}

static	objrtn	_gGetFixedName(object self)
{
	return (*(gGetFixedName_t)_FindMethod(self, Generic(gGetFixedName)))(self);
}

static	float	_gGetFloatFromNode(object self, char *node)
{
	return (*(gGetFloatFromNode_t)_FindMethod(self, Generic(gGetFloatFromNode)))(self, node);
}

static	void *	_gGetGenericPtr(object self)
{
	return (*(gGetGenericPtr_t)_FindMethod(self, Generic(gGetGenericPtr)))(self);
}

static	char *	_gGetHeader(object self, char *name)
{
	return (*(gGetHeader_t)_FindMethod(self, Generic(gGetHeader)))(self, name);
}

static	objrtn	_gGetHeaders(object self)
{
	return (*(gGetHeaders_t)_FindMethod(self, Generic(gGetHeaders)))(self);
}

static	int	_gGetIntFromNode(object self, char *node)
{
	return (*(gGetIntFromNode_t)_FindMethod(self, Generic(gGetIntFromNode)))(self, node);
}

static	objrtn	_gGetMGName(object self)
{
	return (*(gGetMGName_t)_FindMethod(self, Generic(gGetMGName)))(self);
}

static	char *	_gGetName(object self)
{
	return (*(gGetName_t)_FindMethod(self, Generic(gGetName)))(self);
}

static	objrtn	_gGetParent(object self)
{
	return (*(gGetParent_t)_FindMethod(self, Generic(gGetParent)))(self);
}

static	char *	_gGetPeerCertificateIssuerName(object self)
{
	return (*(gGetPeerCertificateIssuerName_t)_FindMethod(self, Generic(gGetPeerCertificateIssuerName)))(self);
}

static	char *	_gGetPeerCertificateSubjectName(object self)
{
	return (*(gGetPeerCertificateSubjectName_t)_FindMethod(self, Generic(gGetPeerCertificateSubjectName)))(self);
}

static	objrtn	_gGetSessionInfo(object self, char **session1, char **session2, char **session3)
{
	return (*(gGetSessionInfo_t)_FindMethod(self, Generic(gGetSessionInfo)))(self, session1, session2, session3);
}

static	int	_gGetStr(object self, char *str)
{
	return (*(gGetStr_t)_FindMethod(self, Generic(gGetStr)))(self, str);
}

static	long	_gGetTotalBytesRead(object self)
{
	return (*(gGetTotalBytesRead_t)_FindMethod(self, Generic(gGetTotalBytesRead)))(self);
}

static	char *	_gGets(object self, char *buf, int n)
{
	return (*(gGets_t)_FindMethod(self, Generic(gGets)))(self, buf, n);
}

static	objrtn	_gGroupRemove(object self, int (*fun)())
{
	return (*(gGroupRemove_t)_FindMethod(self, Generic(gGroupRemove)))(self, fun);
}

static	int	_gHasInputArg(object self)
{
	return (*(gHasInputArg_t)_FindMethod(self, Generic(gHasInputArg)))(self);
}

static	int	_gHash(object self)
{
	return (*(gHash_t)_FindMethod(self, Generic(gHash)))(self);
}

static	objrtn	_gHold(object self)
{
	return (*(gHold_t)_FindMethod(self, Generic(gHold)))(self);
}

static	int	_gHours(object self)
{
	return (*(gHours_t)_FindMethod(self, Generic(gHours)))(self);
}

static	int	_gHowManyBitsOfPeerPublicKey(object self)
{
	return (*(gHowManyBitsOfPeerPublicKey_t)_FindMethod(self, Generic(gHowManyBitsOfPeerPublicKey)))(self);
}

static	unsigned long	_gIPAddress(object self)
{
	return (*(gIPAddress_t)_FindMethod(self, Generic(gIPAddress)))(self);
}

static	char *	_gIPAddressStr(object self, char *buf)
{
	return (*(gIPAddressStr_t)_FindMethod(self, Generic(gIPAddressStr)))(self, buf);
}

static	objrtn	_gIncNelm(object self, int inc)
{
	return (*(gIncNelm_t)_FindMethod(self, Generic(gIncNelm)))(self, inc);
}

static	void *	_gIndex(object self, va_list _rest_)
{
	return (*(gIndex_t)_FindMethod(self, Generic(gIndex)))(self, _rest_);
}

static	objrtn	_gIndexOrigin(object self, int n)
{
	return (*(gIndexOrigin_t)_FindMethod(self, Generic(gIndexOrigin)))(self, n);
}

static	objrtn	_gInit(object self)
{
	return (*(gInit_t)_FindMethod(self, Generic(gInit)))(self);
}

static	objrtn	_gInitLink(object self, object list, object prev, object next)
{
	return (*(gInitLink_t)_FindMethod(self, Generic(gInitLink)))(self, list, prev, next);
}

static	objrtn	_gInsertBefore(object self, object node)
{
	return (*(gInsertBefore_t)_FindMethod(self, Generic(gInsertBefore)))(self, node);
}

static	objrtn	_gInsertObjAt(object self, object lnk, int idx)
{
	return (*(gInsertObjAt_t)_FindMethod(self, Generic(gInsertObjAt)))(self, lnk, idx);
}

static	int	_gInstanceSize(object self)
{
	return (*(gInstanceSize_t)_FindMethod(self, Generic(gInstanceSize)))(self);
}

static	int	_gIntKey(object self)
{
	return (*(gIntKey_t)_FindMethod(self, Generic(gIntKey)))(self);
}

static	int	_gIntValue(object self)
{
	return (*(gIntValue_t)_FindMethod(self, Generic(gIntValue)))(self);
}

static	void	_gInvalidObject(object self, int argn, object arg1)
{
	 (*(gInvalidObject_t)_FindMethod(self, Generic(gInvalidObject)))(self, argn, arg1);
}

static	void	_gInvalidType(object self, int argn, object arg1, object cls, object arg)
{
	 (*(gInvalidType_t)_FindMethod(self, Generic(gInvalidType)))(self, argn, arg1, cls, arg);
}

static	objrtn	_gIota(object self, int n)
{
	return (*(gIota_t)_FindMethod(self, Generic(gIota)))(self, n);
}

static	int	_gIsKindOf(object self, object aCls)
{
	return (*(gIsKindOf_t)_FindMethod(self, Generic(gIsKindOf)))(self, aCls);
}

static	int	_gIsVarArg(object self)
{
	return (*(gIsVarArg_t)_FindMethod(self, Generic(gIsVarArg)))(self);
}

static	long	_gJulToCal(object self, long dt)
{
	return (*(gJulToCal_t)_FindMethod(self, Generic(gJulToCal)))(self, dt);
}

static	long	_gJulian(object self)
{
	return (*(gJulian_t)_FindMethod(self, Generic(gJulian)))(self);
}

static	objrtn	_gJustifyCenter(object self)
{
	return (*(gJustifyCenter_t)_FindMethod(self, Generic(gJustifyCenter)))(self);
}

static	objrtn	_gJustifyLeft(object self)
{
	return (*(gJustifyLeft_t)_FindMethod(self, Generic(gJustifyLeft)))(self);
}

static	objrtn	_gJustifyRight(object self)
{
	return (*(gJustifyRight_t)_FindMethod(self, Generic(gJustifyRight)))(self);
}

static	objrtn	_gKey(object self)
{
	return (*(gKey_t)_FindMethod(self, Generic(gKey)))(self);
}

static	objrtn	_gKill(object self, int rtn)
{
	return (*(gKill_t)_FindMethod(self, Generic(gKill)))(self, rtn);
}

static	objrtn	_gLast(object self)
{
	return (*(gLast_t)_FindMethod(self, Generic(gLast)))(self);
}

static	char *	_gLastArg(object self)
{
	return (*(gLastArg_t)_FindMethod(self, Generic(gLastArg)))(self);
}

static	objrtn	_gLeaveCriticalSection(object self)
{
	return (*(gLeaveCriticalSection_t)_FindMethod(self, Generic(gLeaveCriticalSection)))(self);
}

static	long	_gLength(object self)
{
	return (*(gLength_t)_FindMethod(self, Generic(gLength)))(self);
}

static	int	_gLineHasColon(object self)
{
	return (*(gLineHasColon_t)_FindMethod(self, Generic(gLineHasColon)))(self);
}

static	long	_gLineNumber(object self)
{
	return (*(gLineNumber_t)_FindMethod(self, Generic(gLineNumber)))(self);
}

static	objrtn	_gList(object self)
{
	return (*(gList_t)_FindMethod(self, Generic(gList)))(self);
}

static	objrtn	_gLoadJavaClass(object self, char *name)
{
	return (*(gLoadJavaClass_t)_FindMethod(self, Generic(gLoadJavaClass)))(self, name);
}

static	char *	_gLoadMask(object self, char *inmask)
{
	return (*(gLoadMask_t)_FindMethod(self, Generic(gLoadMask)))(self, inmask);
}

static	int	_gLock(object self, unsigned long start, unsigned long len, int wait)
{
	return (*(gLock_t)_FindMethod(self, Generic(gLock)))(self, start, len, wait);
}

static	long	_gLongValue(object self)
{
	return (*(gLongValue_t)_FindMethod(self, Generic(gLongValue)))(self);
}

static	objrtn	_gLookup(object self, object luk, int mode, int deep, int type, object value)
{
	return (*(gLookup_t)_FindMethod(self, Generic(gLookup)))(self, luk, mode, deep, type, value);
}

static	objrtn	_gMakeServer(object self, int port, int ssl)
{
	return (*(gMakeServer_t)_FindMethod(self, Generic(gMakeServer)))(self, port, ssl);
}

static	objrtn	_gMarkMemoryBeginning(object self)
{
	return (*(gMarkMemoryBeginning_t)_FindMethod(self, Generic(gMarkMemoryBeginning)))(self);
}

static	void	_gMarkObject(object self, object obj)
{
	 (*(gMarkObject_t)_FindMethod(self, Generic(gMarkObject)))(self, obj);
}

static	void	_gMarkRange(object self, char _HUGE_ **from, char _HUGE_ **to)
{
	 (*(gMarkRange_t)_FindMethod(self, Generic(gMarkRange)))(self, from, to);
}

static	objrtn	_gMarkingMethod(object self, ofun mf)
{
	return (*(gMarkingMethod_t)_FindMethod(self, Generic(gMarkingMethod)))(self, mf);
}

static	ifun	_gMaskFunction(object self, char ch)
{
	return (*(gMaskFunction_t)_FindMethod(self, Generic(gMaskFunction)))(self, ch);
}

static	int	_gMatch(object self, object mproto)
{
	return (*(gMatch_t)_FindMethod(self, Generic(gMatch)))(self, mproto);
}

static	int	_gMatchNoError(object self, object mproto)
{
	return (*(gMatchNoError_t)_FindMethod(self, Generic(gMatchNoError)))(self, mproto);
}

static	long	_gMaxAfterGC(object self)
{
	return (*(gMaxAfterGC_t)_FindMethod(self, Generic(gMaxAfterGC)))(self);
}

static	long	_gMaxMemUsed(object self)
{
	return (*(gMaxMemUsed_t)_FindMethod(self, Generic(gMaxMemUsed)))(self);
}

static	int	_gMilliseconds(object self)
{
	return (*(gMilliseconds_t)_FindMethod(self, Generic(gMilliseconds)))(self);
}

static	int	_gMinutes(object self)
{
	return (*(gMinutes_t)_FindMethod(self, Generic(gMinutes)))(self);
}

static	objrtn	_gMode(object self, int rblock, int wblock)
{
	return (*(gMode_t)_FindMethod(self, Generic(gMode)))(self, rblock, wblock);
}

static	objrtn	_gMonthName(object self)
{
	return (*(gMonthName_t)_FindMethod(self, Generic(gMonthName)))(self);
}

static	objrtn	_gMoreHandles(object self)
{
	return (*(gMoreHandles_t)_FindMethod(self, Generic(gMoreHandles)))(self);
}

static	objrtn	_gMoveAfter(object self, object lnk)
{
	return (*(gMoveAfter_t)_FindMethod(self, Generic(gMoveAfter)))(self, lnk);
}

static	objrtn	_gMoveBefore(object self, object lnk)
{
	return (*(gMoveBefore_t)_FindMethod(self, Generic(gMoveBefore)))(self, lnk);
}

static	objrtn	_gMoveBeginning(object self)
{
	return (*(gMoveBeginning_t)_FindMethod(self, Generic(gMoveBeginning)))(self);
}

static	objrtn	_gMoveEnd(object self)
{
	return (*(gMoveEnd_t)_FindMethod(self, Generic(gMoveEnd)))(self);
}

static	char *	_gName(object self)
{
	return (*(gName_t)_FindMethod(self, Generic(gName)))(self);
}

static	objrtn	_gNew(object self)
{
	return (*(gNew_t)_FindMethod(self, Generic(gNew)))(self);
}

static	objrtn	_gNewArglist(object self, int argc, char **argv)
{
	return (*(gNewArglist_t)_FindMethod(self, Generic(gNewArglist)))(self, argc, argv);
}

static	objrtn	_gNewArray(object self, int type, int rank, va_list _rest_)
{
	return (*(gNewArray_t)_FindMethod(self, Generic(gNewArray)))(self, type, rank, _rest_);
}

static	objrtn	_gNewClass(object self, char *name, int ivsize, int cvsize, object superclasses, ...)
{
	va_list _rest_;
	va_start(_rest_, superclasses);
	return (*(gNewClass_t)_FindMethod(self, Generic(gNewClass)))(self, name, ivsize, cvsize, superclasses, _rest_);
}

static	objrtn	_gNewDateTime(object self, long dt, long tm)
{
	return (*(gNewDateTime_t)_FindMethod(self, Generic(gNewDateTime)))(self, dt, tm);
}

static	objrtn	_gNewDocument(object self)
{
	return (*(gNewDocument_t)_FindMethod(self, Generic(gNewDocument)))(self);
}

static	objrtn	_gNewFindFile(object self, char *name, int attr)
{
	return (*(gNewFindFile_t)_FindMethod(self, Generic(gNewFindFile)))(self, name, attr);
}

static	objrtn	_gNewGeneric(object self, char *n, void *fp)
{
	return (*(gNewGeneric_t)_FindMethod(self, Generic(gNewGeneric)))(self, n, fp);
}

static	objrtn	_gNewGlobalPool(object self)
{
	return (*(gNewGlobalPool_t)_FindMethod(self, Generic(gNewGlobalPool)))(self);
}

static	objrtn	_gNewGlobalPoolWithSize(object self, int siz)
{
	return (*(gNewGlobalPoolWithSize_t)_FindMethod(self, Generic(gNewGlobalPoolWithSize)))(self, siz);
}

static	objrtn	_gNewMethod(object self, char *n, object c, object gen, ofun methf, ofun methf2)
{
	return (*(gNewMethod_t)_FindMethod(self, Generic(gNewMethod)))(self, n, c, gen, methf, methf2);
}

static	objrtn	_gNewMimeBodyPart(object self, char *content)
{
	return (*(gNewMimeBodyPart_t)_FindMethod(self, Generic(gNewMimeBodyPart)))(self, content);
}

static	objrtn	_gNewMultipartMime(object self, char *subType, char *boundaryString)
{
	return (*(gNewMultipartMime_t)_FindMethod(self, Generic(gNewMultipartMime)))(self, subType, boundaryString);
}

static	objrtn	_gNewNode(object self, object btree, int type)
{
	return (*(gNewNode_t)_FindMethod(self, Generic(gNewNode)))(self, btree, type);
}

static	objrtn	_gNewSemaphore(object self, char *name, int cnt, int mx)
{
	return (*(gNewSemaphore_t)_FindMethod(self, Generic(gNewSemaphore)))(self, name, cnt, mx);
}

static	objrtn	_gNewSetSeq(object self, int size, int nelm, void *tab)
{
	return (*(gNewSetSeq_t)_FindMethod(self, Generic(gNewSetSeq)))(self, size, nelm, tab);
}

static	objrtn	_gNewStdClass(object self, char *name, int ivsize, object mc, int nipib, object superclasses, ...)
{
	va_list _rest_;
	va_start(_rest_, superclasses);
	return (*(gNewStdClass_t)_FindMethod(self, Generic(gNewStdClass)))(self, name, ivsize, mc, nipib, superclasses, _rest_);
}

static	objrtn	_gNewThread(object self, char *name, ifun fun, int priority, void *arg, int run, int autoDispose)
{
	return (*(gNewThread_t)_FindMethod(self, Generic(gNewThread)))(self, name, fun, priority, arg, run, autoDispose);
}

static	objrtn	_gNewToken(object self, char *tkn, long ln, int sp)
{
	return (*(gNewToken_t)_FindMethod(self, Generic(gNewToken)))(self, tkn, ln, sp);
}

static	objrtn	_gNewWithChar(object self, int val)
{
	return (*(gNewWithChar_t)_FindMethod(self, Generic(gNewWithChar)))(self, val);
}

static	objrtn	_gNewWithDouble(object self, double val)
{
	return (*(gNewWithDouble_t)_FindMethod(self, Generic(gNewWithDouble)))(self, val);
}

static	objrtn	_gNewWithInt(object self, int val)
{
	return (*(gNewWithInt_t)_FindMethod(self, Generic(gNewWithInt)))(self, val);
}

static	objrtn	_gNewWithIntObj(object self, int key, object value)
{
	return (*(gNewWithIntObj_t)_FindMethod(self, Generic(gNewWithIntObj)))(self, key, value);
}

static	objrtn	_gNewWithLong(object self, long val)
{
	return (*(gNewWithLong_t)_FindMethod(self, Generic(gNewWithLong)))(self, val);
}

static	objrtn	_gNewWithObj(object self, object value)
{
	return (*(gNewWithObj_t)_FindMethod(self, Generic(gNewWithObj)))(self, value);
}

static	objrtn	_gNewWithObjObj(object self, object key, object val)
{
	return (*(gNewWithObjObj_t)_FindMethod(self, Generic(gNewWithObjObj)))(self, key, val);
}

static	objrtn	_gNewWithPtr(object self, void *val)
{
	return (*(gNewWithPtr_t)_FindMethod(self, Generic(gNewWithPtr)))(self, val);
}

static	objrtn	_gNewWithStr(object self, char *so)
{
	return (*(gNewWithStr_t)_FindMethod(self, Generic(gNewWithStr)))(self, so);
}

static	objrtn	_gNewWithStrInt(object self, char *name, int bufsiz)
{
	return (*(gNewWithStrInt_t)_FindMethod(self, Generic(gNewWithStrInt)))(self, name, bufsiz);
}

static	objrtn	_gNewWithStrObj(object self, char *key, object val)
{
	return (*(gNewWithStrObj_t)_FindMethod(self, Generic(gNewWithStrObj)))(self, key, val);
}

static	objrtn	_gNewWithStrStr(object self, char *nm, char *rt)
{
	return (*(gNewWithStrStr_t)_FindMethod(self, Generic(gNewWithStrStr)))(self, nm, rt);
}

static	objrtn	_gNewWithStream(object self, char *name, FILE *fp)
{
	return (*(gNewWithStream_t)_FindMethod(self, Generic(gNewWithStream)))(self, name, fp);
}

static	objrtn	_gNewWithUnsigned(object self, unsigned val)
{
	return (*(gNewWithUnsigned_t)_FindMethod(self, Generic(gNewWithUnsigned)))(self, val);
}

static	objrtn	_gNext(object self)
{
	return (*(gNext_t)_FindMethod(self, Generic(gNext)))(self);
}

static	char *	_gNextFile(object self)
{
	return (*(gNextFile_t)_FindMethod(self, Generic(gNextFile)))(self);
}

static	objrtn	_gNextToken(object self)
{
	return (*(gNextToken_t)_FindMethod(self, Generic(gNextToken)))(self);
}

static	objrtn	_gNow(object self)
{
	return (*(gNow_t)_FindMethod(self, Generic(gNow)))(self);
}

static	objrtn	_gNth(object self, int idx)
{
	return (*(gNth_t)_FindMethod(self, Generic(gNth)))(self, idx);
}

static	long	_gNumbGC(object self)
{
	return (*(gNumbGC_t)_FindMethod(self, Generic(gNumbGC)))(self);
}

static	int	_gNumbPieces(object self, char d)
{
	return (*(gNumbPieces_t)_FindMethod(self, Generic(gNumbPieces)))(self, d);
}

static	objrtn	_gObjectChecking(object self, int x)
{
	return (*(gObjectChecking_t)_FindMethod(self, Generic(gObjectChecking)))(self, x);
}

static	unsigned long	_gObjectSerialNumber(object self)
{
	return (*(gObjectSerialNumber_t)_FindMethod(self, Generic(gObjectSerialNumber)))(self);
}

static	objrtn	_gOpenFile(object self, char *name, char *mode)
{
	return (*(gOpenFile_t)_FindMethod(self, Generic(gOpenFile)))(self, name, mode);
}

static	objrtn	_gOpenLowFile(object self, char *name, int oflag, int pmode)
{
	return (*(gOpenLowFile_t)_FindMethod(self, Generic(gOpenLowFile)))(self, name, oflag, pmode);
}

static	objrtn	_gOpenStream2(object self, char *file, char *ifile)
{
	return (*(gOpenStream2_t)_FindMethod(self, Generic(gOpenStream2)))(self, file, ifile);
}

static	objrtn	_gOpenTempFile(object self)
{
	return (*(gOpenTempFile_t)_FindMethod(self, Generic(gOpenTempFile)))(self);
}

static	objrtn	_gParameters(object self)
{
	return (*(gParameters_t)_FindMethod(self, Generic(gParameters)))(self);
}

static	objrtn	_gParent(object self)
{
	return (*(gParent_t)_FindMethod(self, Generic(gParent)))(self);
}

static	objrtn	_gParseFile(object self, char *file, long *line, long *col, long *pos)
{
	return (*(gParseFile_t)_FindMethod(self, Generic(gParseFile)))(self, file, line, col, pos);
}

static	objrtn	_gParseMultipartFromString(object self, char *content, char *boundary)
{
	return (*(gParseMultipartFromString_t)_FindMethod(self, Generic(gParseMultipartFromString)))(self, content, boundary);
}

static	objrtn	_gParseString(object self, char *str, long *line, long *col, long *pos)
{
	return (*(gParseString_t)_FindMethod(self, Generic(gParseString)))(self, str, line, col, pos);
}

static	objrtn	_gPiece(object self, char d, int n)
{
	return (*(gPiece_t)_FindMethod(self, Generic(gPiece)))(self, d, n);
}

static	void *	_gPointerValue(object self)
{
	return (*(gPointerValue_t)_FindMethod(self, Generic(gPointerValue)))(self);
}

static	objrtn	_gPop(object self)
{
	return (*(gPop_t)_FindMethod(self, Generic(gPop)))(self);
}

static	objrtn	_gPopulateStringFromNode(object self, char *to, char *node)
{
	return (*(gPopulateStringFromNode_t)_FindMethod(self, Generic(gPopulateStringFromNode)))(self, to, node);
}

static	long	_gPosition(object self)
{
	return (*(gPosition_t)_FindMethod(self, Generic(gPosition)))(self);
}

static	objrtn	_gPrevious(object self)
{
	return (*(gPrevious_t)_FindMethod(self, Generic(gPrevious)))(self);
}

static	objrtn	_gPrint(object self, object stream)
{
	return (*(gPrint_t)_FindMethod(self, Generic(gPrint)))(self, stream);
}

static	objrtn	_gPrintArgs(object self, object fobj)
{
	return (*(gPrintArgs_t)_FindMethod(self, Generic(gPrintArgs)))(self, fobj);
}

static	objrtn	_gPrintFixedArgs(object self, object fobj)
{
	return (*(gPrintFixedArgs_t)_FindMethod(self, Generic(gPrintFixedArgs)))(self, fobj);
}

static	int	_gPrintLength(object self, int t)
{
	return (*(gPrintLength_t)_FindMethod(self, Generic(gPrintLength)))(self, t);
}

static	objrtn	_gPrintMethArgs(object self, object fobj, int Strategy, int vararg)
{
	return (*(gPrintMethArgs_t)_FindMethod(self, Generic(gPrintMethArgs)))(self, fobj, Strategy, vararg);
}

static	objrtn	_gPrintValue(object self, object stream)
{
	return (*(gPrintValue_t)_FindMethod(self, Generic(gPrintValue)))(self, stream);
}

static	objrtn	_gPrintVars(object self, object fobj)
{
	return (*(gPrintVars_t)_FindMethod(self, Generic(gPrintVars)))(self, fobj);
}

static	int	_gPriority(object self)
{
	return (*(gPriority_t)_FindMethod(self, Generic(gPriority)))(self);
}

static	objrtn	_gProcess(object self)
{
	return (*(gProcess_t)_FindMethod(self, Generic(gProcess)))(self);
}

static	objrtn	_gPropertyGet(object self, char *prop)
{
	return (*(gPropertyGet_t)_FindMethod(self, Generic(gPropertyGet)))(self, prop);
}

static	objrtn	_gPropertyPut(object self, char *prop, int autoDispose, object val)
{
	return (*(gPropertyPut_t)_FindMethod(self, Generic(gPropertyPut)))(self, prop, autoDispose, val);
}

static	objrtn	_gPropertyRemove(object self, char *prop)
{
	return (*(gPropertyRemove_t)_FindMethod(self, Generic(gPropertyRemove)))(self, prop);
}

static	objrtn	_gPropertySetAutoDispose(object self, char *prop, int autoDispose)
{
	return (*(gPropertySetAutoDispose_t)_FindMethod(self, Generic(gPropertySetAutoDispose)))(self, prop, autoDispose);
}

static	objrtn	_gPrototype(object self)
{
	return (*(gPrototype_t)_FindMethod(self, Generic(gPrototype)))(self);
}

static	objrtn	_gProxyConnect(object self, char *addr, int port, short int flag, char *proxy_addr, int proxy_port, char *proxy_user, char *proxy_pw)
{
	return (*(gProxyConnect_t)_FindMethod(self, Generic(gProxyConnect)))(self, addr, port, flag, proxy_addr, proxy_port, proxy_user, proxy_pw);
}

static	objrtn	_gPush(object self, object obj)
{
	return (*(gPush_t)_FindMethod(self, Generic(gPush)))(self, obj);
}

static	objrtn	_gPut(object self, object tkn)
{
	return (*(gPut_t)_FindMethod(self, Generic(gPut)))(self, tkn);
}

static	int	_gPutc(object self, int i)
{
	return (*(gPutc_t)_FindMethod(self, Generic(gPutc)))(self, i);
}

static	objrtn	_gPutm(object self, object tkn)
{
	return (*(gPutm_t)_FindMethod(self, Generic(gPutm)))(self, tkn);
}

static	int	_gPuts(object self, char *str)
{
	return (*(gPuts_t)_FindMethod(self, Generic(gPuts)))(self, str);
}

static	unsigned	_gRank(object self)
{
	return (*(gRank_t)_FindMethod(self, Generic(gRank)))(self);
}

static	int	_gRead(object self, char *buf, unsigned n)
{
	return (*(gRead_t)_FindMethod(self, Generic(gRead)))(self, buf, n);
}

static	int	_gReadInt32(object self, int *val)
{
	return (*(gReadInt32_t)_FindMethod(self, Generic(gReadInt32)))(self, val);
}

static	int	_gRecvFile(object self, char *toFile)
{
	return (*(gRecvFile_t)_FindMethod(self, Generic(gRecvFile)))(self, toFile);
}

static	void *	_gRegisterMemory(object self, void *beg, long size)
{
	return (*(gRegisterMemory_t)_FindMethod(self, Generic(gRegisterMemory)))(self, beg, size);
}

static	objrtn	_gRelease(object self, int yld)
{
	return (*(gRelease_t)_FindMethod(self, Generic(gRelease)))(self, yld);
}

static	objrtn	_gReleaseSemaphore(object self)
{
	return (*(gReleaseSemaphore_t)_FindMethod(self, Generic(gReleaseSemaphore)))(self);
}

static	objrtn	_gRemove(object self)
{
	return (*(gRemove_t)_FindMethod(self, Generic(gRemove)))(self);
}

static	objrtn	_gRemoveAttribute(object self, char *name)
{
	return (*(gRemoveAttribute_t)_FindMethod(self, Generic(gRemoveAttribute)))(self, name);
}

static	objrtn	_gRemoveFirst(object self)
{
	return (*(gRemoveFirst_t)_FindMethod(self, Generic(gRemoveFirst)))(self);
}

static	objrtn	_gRemoveFromPool(object self, object obj)
{
	return (*(gRemoveFromPool_t)_FindMethod(self, Generic(gRemoveFromPool)))(self, obj);
}

static	objrtn	_gRemoveInt(object self, int key)
{
	return (*(gRemoveInt_t)_FindMethod(self, Generic(gRemoveInt)))(self, key);
}

static	objrtn	_gRemoveLast(object self)
{
	return (*(gRemoveLast_t)_FindMethod(self, Generic(gRemoveLast)))(self);
}

static	objrtn	_gRemoveMask(object self, char *inmask, char *text)
{
	return (*(gRemoveMask_t)_FindMethod(self, Generic(gRemoveMask)))(self, inmask, text);
}

static	objrtn	_gRemoveNode(object self)
{
	return (*(gRemoveNode_t)_FindMethod(self, Generic(gRemoveNode)))(self);
}

static	objrtn	_gRemoveObj(object self, object luk)
{
	return (*(gRemoveObj_t)_FindMethod(self, Generic(gRemoveObj)))(self, luk);
}

static	void	_gRemoveRegisteredMemory(object self, void *pp)
{
	 (*(gRemoveRegisteredMemory_t)_FindMethod(self, Generic(gRemoveRegisteredMemory)))(self, pp);
}

static	objrtn	_gRemoveStr(object self, char *key)
{
	return (*(gRemoveStr_t)_FindMethod(self, Generic(gRemoveStr)))(self, key);
}

static	objrtn	_gRemoveWaits(object self, object thrd)
{
	return (*(gRemoveWaits_t)_FindMethod(self, Generic(gRemoveWaits)))(self, thrd);
}

static	objrtn	_gResize(object self, int size)
{
	return (*(gResize_t)_FindMethod(self, Generic(gResize)))(self, size);
}

static	objrtn	_gResizeMethodCache(object self, int classes, int generics)
{
	return (*(gResizeMethodCache_t)_FindMethod(self, Generic(gResizeMethodCache)))(self, classes, generics);
}

static	long	_gRetreat(object self, long n)
{
	return (*(gRetreat_t)_FindMethod(self, Generic(gRetreat)))(self, n);
}

static	objrtn	_gReturnType(object self)
{
	return (*(gReturnType_t)_FindMethod(self, Generic(gReturnType)))(self);
}

static	int	_gRoom(object self)
{
	return (*(gRoom_t)_FindMethod(self, Generic(gRoom)))(self);
}

static	objrtn	_gRound(object self, int p)
{
	return (*(gRound_t)_FindMethod(self, Generic(gRound)))(self, p);
}

static	objrtn	_gSLineDirective(object self)
{
	return (*(gSLineDirective_t)_FindMethod(self, Generic(gSLineDirective)))(self);
}

static	int	_gSaveXML(object self, char *file)
{
	return (*(gSaveXML_t)_FindMethod(self, Generic(gSaveXML)))(self, file);
}

static	int	_gSeconds(object self)
{
	return (*(gSeconds_t)_FindMethod(self, Generic(gSeconds)))(self);
}

static	long	_gSeek(object self, long n)
{
	return (*(gSeek_t)_FindMethod(self, Generic(gSeek)))(self, n);
}

static	int	_gSendFile(object self, char *fromFile, char *toFile)
{
	return (*(gSendFile_t)_FindMethod(self, Generic(gSendFile)))(self, fromFile, toFile);
}

static	int	_gSendStr(object self, char *str)
{
	return (*(gSendStr_t)_FindMethod(self, Generic(gSendStr)))(self, str);
}

static	objrtn	_gSequence(object self)
{
	return (*(gSequence_t)_FindMethod(self, Generic(gSequence)))(self);
}

static	objrtn	_gSequenceLinks(object self)
{
	return (*(gSequenceLinks_t)_FindMethod(self, Generic(gSequenceLinks)))(self);
}

static	objrtn	_gServerSocketConnect(object self)
{
	return (*(gServerSocketConnect_t)_FindMethod(self, Generic(gServerSocketConnect)))(self);
}

static	objrtn	_gSetArgs(object self, object ar)
{
	return (*(gSetArgs_t)_FindMethod(self, Generic(gSetArgs)))(self, ar);
}

static	objrtn	_gSetAttribute(object self, char *name, char *value)
{
	return (*(gSetAttribute_t)_FindMethod(self, Generic(gSetAttribute)))(self, name, value);
}

static	ifun	_gSetErrorFunction(object self, ifun fun)
{
	return (*(gSetErrorFunction_t)_FindMethod(self, Generic(gSetErrorFunction)))(self, fun);
}

static	ofun	_gSetFunction(object self, int (*fun)())
{
	return (*(gSetFunction_t)_FindMethod(self, Generic(gSetFunction)))(self, fun);
}

static	char	_gSetMaskFiller(object self, char ch)
{
	return (*(gSetMaskFiller_t)_FindMethod(self, Generic(gSetMaskFiller)))(self, ch);
}

static	objrtn	_gSetMemoryBufferArea(object self, long sz)
{
	return (*(gSetMemoryBufferArea_t)_FindMethod(self, Generic(gSetMemoryBufferArea)))(self, sz);
}

static	ifun	_gSetMoreHandles(object self, ifun fun)
{
	return (*(gSetMoreHandles_t)_FindMethod(self, Generic(gSetMoreHandles)))(self, fun);
}

static	objrtn	_gSetNodeName(object self, char *txt)
{
	return (*(gSetNodeName_t)_FindMethod(self, Generic(gSetNodeName)))(self, txt);
}

static	objrtn	_gSetNodeValue(object self, char *txt)
{
	return (*(gSetNodeValue_t)_FindMethod(self, Generic(gSetNodeValue)))(self, txt);
}

static	objrtn	_gSetOSVars(object self, object cname, object cvs, object ivs)
{
	return (*(gSetOSVars_t)_FindMethod(self, Generic(gSetOSVars)))(self, cname, cvs, ivs);
}

static	objrtn	_gSetPropertyList(object self, object pl)
{
	return (*(gSetPropertyList_t)_FindMethod(self, Generic(gSetPropertyList)))(self, pl);
}

static	objrtn	_gSetTempSubDir(object self, char *dir)
{
	return (*(gSetTempSubDir_t)_FindMethod(self, Generic(gSetTempSubDir)))(self, dir);
}

static	objrtn	_gSetTopNode(object self, object newNode)
{
	return (*(gSetTopNode_t)_FindMethod(self, Generic(gSetTopNode)))(self, newNode);
}

static	objrtn	_gShape(object self)
{
	return (*(gShape_t)_FindMethod(self, Generic(gShape)))(self);
}

static	short	_gShortValue(object self)
{
	return (*(gShortValue_t)_FindMethod(self, Generic(gShortValue)))(self);
}

static	objrtn	_gShouldNotImplement(object self, char *meth)
{
	return (*(gShouldNotImplement_t)_FindMethod(self, Generic(gShouldNotImplement)))(self, meth);
}

static	objrtn	_gSignal(object self)
{
	return (*(gSignal_t)_FindMethod(self, Generic(gSignal)))(self);
}

static	int	_gSize(object self)
{
	return (*(gSize_t)_FindMethod(self, Generic(gSize)))(self);
}

static	objrtn	_gSocketConnect(object self, char *addr, int port, short int flag)
{
	return (*(gSocketConnect_t)_FindMethod(self, Generic(gSocketConnect)))(self, addr, port, flag);
}

static	int	_gSpace(object self)
{
	return (*(gSpace_t)_FindMethod(self, Generic(gSpace)))(self);
}

static	objrtn	_gStackAlloc(object self, void *p)
{
	return (*(gStackAlloc_t)_FindMethod(self, Generic(gStackAlloc)))(self, p);
}

static	int	_gState(object self)
{
	return (*(gState_t)_FindMethod(self, Generic(gState)))(self);
}

static	char *	_gStringKey(object self)
{
	return (*(gStringKey_t)_FindMethod(self, Generic(gStringKey)))(self);
}

static	objrtn	_gStringRep(object self)
{
	return (*(gStringRep_t)_FindMethod(self, Generic(gStringRep)))(self);
}

static	objrtn	_gStringRepValue(object self)
{
	return (*(gStringRepValue_t)_FindMethod(self, Generic(gStringRepValue)))(self);
}

static	char *	_gStringToXML(object self, char *to, char *from)
{
	return (*(gStringToXML_t)_FindMethod(self, Generic(gStringToXML)))(self, to, from);
}

static	char *	_gStringValue(object self)
{
	return (*(gStringValue_t)_FindMethod(self, Generic(gStringValue)))(self);
}

static	objrtn	_gStripCenter(object self)
{
	return (*(gStripCenter_t)_FindMethod(self, Generic(gStripCenter)))(self);
}

static	objrtn	_gStripLeft(object self)
{
	return (*(gStripLeft_t)_FindMethod(self, Generic(gStripLeft)))(self);
}

static	objrtn	_gStripRight(object self)
{
	return (*(gStripRight_t)_FindMethod(self, Generic(gStripRight)))(self);
}

static	objrtn	_gSubClasses(object self)
{
	return (*(gSubClasses_t)_FindMethod(self, Generic(gSubClasses)))(self);
}

static	objrtn	_gSubString(object self, int beg, int num)
{
	return (*(gSubString_t)_FindMethod(self, Generic(gSubString)))(self, beg, num);
}

static	objrtn	_gSubclassResponsibility(object self, char *meth)
{
	return (*(gSubclassResponsibility_t)_FindMethod(self, Generic(gSubclassResponsibility)))(self, meth);
}

static	objrtn	_gSuperClasses(object self)
{
	return (*(gSuperClasses_t)_FindMethod(self, Generic(gSuperClasses)))(self);
}

static	objrtn	_gTLineDirective(object self)
{
	return (*(gTLineDirective_t)_FindMethod(self, Generic(gTLineDirective)))(self);
}

static	objrtn	_gTake(object self, int n)
{
	return (*(gTake_t)_FindMethod(self, Generic(gTake)))(self, n);
}

static	long	_gTimeDifference(object self, object tm)
{
	return (*(gTimeDifference_t)_FindMethod(self, Generic(gTimeDifference)))(self, tm);
}

static	objrtn	_gTimeStringRepValue(object self)
{
	return (*(gTimeStringRepValue_t)_FindMethod(self, Generic(gTimeStringRepValue)))(self);
}

static	long	_gTimeValue(object self)
{
	return (*(gTimeValue_t)_FindMethod(self, Generic(gTimeValue)))(self);
}

static	int	_gTimedRead(object self, char *buf, unsigned n, int max_wait)
{
	return (*(gTimedRead_t)_FindMethod(self, Generic(gTimedRead)))(self, buf, n, max_wait);
}

static	int	_gTimedReadMS(object self, char *buf, unsigned n, int max_wait, long microsec_wait)
{
	return (*(gTimedReadMS_t)_FindMethod(self, Generic(gTimedReadMS)))(self, buf, n, max_wait, microsec_wait);
}

static	int	_gTimedWrite(object self, char *buf, unsigned n, int max_wait)
{
	return (*(gTimedWrite_t)_FindMethod(self, Generic(gTimedWrite)))(self, buf, n, max_wait);
}

static	objrtn	_gToLower(object self)
{
	return (*(gToLower_t)_FindMethod(self, Generic(gToLower)))(self);
}

static	objrtn	_gToUpper(object self)
{
	return (*(gToUpper_t)_FindMethod(self, Generic(gToUpper)))(self);
}

static	objrtn	_gToday(object self)
{
	return (*(gToday_t)_FindMethod(self, Generic(gToday)))(self);
}

static	objrtn	_gToken(object self)
{
	return (*(gToken_t)_FindMethod(self, Generic(gToken)))(self);
}

static	int	_gTrace(object self, int mode)
{
	return (*(gTrace_t)_FindMethod(self, Generic(gTrace)))(self, mode);
}

static	objrtn	_gTracePrint(object self, char *buf)
{
	return (*(gTracePrint_t)_FindMethod(self, Generic(gTracePrint)))(self, buf);
}

static	objrtn	_gTruncate(object self, int p)
{
	return (*(gTruncate_t)_FindMethod(self, Generic(gTruncate)))(self, p);
}

static	int	_gType(object self)
{
	return (*(gType_t)_FindMethod(self, Generic(gType)))(self);
}

static	int	_gUnLock(object self, unsigned long start, unsigned long len)
{
	return (*(gUnLock_t)_FindMethod(self, Generic(gUnLock)))(self, start, len);
}

static	unsigned short	_gUnsignedShortValue(object self)
{
	return (*(gUnsignedShortValue_t)_FindMethod(self, Generic(gUnsignedShortValue)))(self);
}

static	objrtn	_gUpdateLength(object self)
{
	return (*(gUpdateLength_t)_FindMethod(self, Generic(gUpdateLength)))(self);
}

static	objrtn	_gUseStream(object self, int n)
{
	return (*(gUseStream_t)_FindMethod(self, Generic(gUseStream)))(self, n);
}

static	objrtn	_gUseVars(object self, object fobj)
{
	return (*(gUseVars_t)_FindMethod(self, Generic(gUseVars)))(self, fobj);
}

static	int	_gValidDate(object self)
{
	return (*(gValidDate_t)_FindMethod(self, Generic(gValidDate)))(self);
}

static	int	_gValidDateTime(object self)
{
	return (*(gValidDateTime_t)_FindMethod(self, Generic(gValidDateTime)))(self);
}

static	int	_gValidTime(object self)
{
	return (*(gValidTime_t)_FindMethod(self, Generic(gValidTime)))(self);
}

static	objrtn	_gValue(object self)
{
	return (*(gValue_t)_FindMethod(self, Generic(gValue)))(self);
}

static	objrtn	_gVarArg(object self)
{
	return (*(gVarArg_t)_FindMethod(self, Generic(gVarArg)))(self);
}

static	int	_gWaitFor(object self)
{
	return (*(gWaitFor_t)_FindMethod(self, Generic(gWaitFor)))(self);
}

static	objrtn	_gWaitSemaphore(object self, object sema)
{
	return (*(gWaitSemaphore_t)_FindMethod(self, Generic(gWaitSemaphore)))(self, sema);
}

static	int	_gWrite(object self, char *buf, unsigned len)
{
	return (*(gWrite_t)_FindMethod(self, Generic(gWrite)))(self, buf, len);
}

static	int	_gWriteInt32(object self, int val)
{
	return (*(gWriteInt32_t)_FindMethod(self, Generic(gWriteInt32)))(self, val);
}

static	long	_gWriteTime(object self)
{
	return (*(gWriteTime_t)_FindMethod(self, Generic(gWriteTime)))(self);
}

static	char *	_gXMLToString(object self, char *to, char *from)
{
	return (*(gXMLToString_t)_FindMethod(self, Generic(gXMLToString)))(self, to, from);
}

static	objrtn	_gXPath(object self, char *path)
{
	return (*(gXPath_t)_FindMethod(self, Generic(gXPath)))(self, path);
}

static	int	_vBitValue(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vBitValue_t)_FindMethod(self, Generic(vBitValue)))(self, _rest_);
}

static	objrtn	_vBuild(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vBuild_t)_FindMethod(self, Generic(vBuild)))(self, _rest_);
}

static	objrtn	_vChangeBitValue(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vChangeBitValue_t)_FindMethod(self, Generic(vChangeBitValue)))(self, _rest_);
}

static	objrtn	_vChangeCharValue(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vChangeCharValue_t)_FindMethod(self, Generic(vChangeCharValue)))(self, _rest_);
}

static	objrtn	_vChangeDoubleValue(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vChangeDoubleValue_t)_FindMethod(self, Generic(vChangeDoubleValue)))(self, _rest_);
}

static	objrtn	_vChangeLongValue(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vChangeLongValue_t)_FindMethod(self, Generic(vChangeLongValue)))(self, _rest_);
}

static	objrtn	_vChangeShortValue(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vChangeShortValue_t)_FindMethod(self, Generic(vChangeShortValue)))(self, _rest_);
}

static	objrtn	_vChangeUShortValue(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vChangeUShortValue_t)_FindMethod(self, Generic(vChangeUShortValue)))(self, _rest_);
}

static	objrtn	_vChangeValue(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vChangeValue_t)_FindMethod(self, Generic(vChangeValue)))(self, _rest_);
}

static	char	_vCharValue(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vCharValue_t)_FindMethod(self, Generic(vCharValue)))(self, _rest_);
}

static	double	_vDoubleValue(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vDoubleValue_t)_FindMethod(self, Generic(vDoubleValue)))(self, _rest_);
}

static	objrtn	_vError(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vError_t)_FindMethod(self, Generic(vError)))(self, _rest_);
}

static	objrtn	_vGetValues(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vGetValues_t)_FindMethod(self, Generic(vGetValues)))(self, _rest_);
}

static	long	_vLongValue(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vLongValue_t)_FindMethod(self, Generic(vLongValue)))(self, _rest_);
}

static	objrtn	_vMakeList(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vMakeList_t)_FindMethod(self, Generic(vMakeList)))(self, _rest_);
}

static	objrtn	_vNew(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vNew_t)_FindMethod(self, Generic(vNew)))(self, _rest_);
}

static	void *	_vPointerValue(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vPointerValue_t)_FindMethod(self, Generic(vPointerValue)))(self, _rest_);
}

static	int	_vPrintf(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vPrintf_t)_FindMethod(self, Generic(vPrintf)))(self, _rest_);
}

static	objrtn	_vReshape(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vReshape_t)_FindMethod(self, Generic(vReshape)))(self, _rest_);
}

static	short	_vShortValue(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vShortValue_t)_FindMethod(self, Generic(vShortValue)))(self, _rest_);
}

static	objrtn	_vSprintf(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vSprintf_t)_FindMethod(self, Generic(vSprintf)))(self, _rest_);
}

static	unsigned short	_vUnsignedShortValue(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vUnsignedShortValue_t)_FindMethod(self, Generic(vUnsignedShortValue)))(self, _rest_);
}

static	objrtn	_vValue(object self, ...)
{
	va_list _rest_;
	va_start(_rest_, self);
	return (*(vValue_t)_FindMethod(self, Generic(vValue)))(self, _rest_);
}

gAccept_t	gAccept = _gAccept;
gAdd_t	gAdd = _gAdd;
gAddAfter_t	gAddAfter = _gAddAfter;
gAddBTreeNode_t	gAddBTreeNode = _gAddBTreeNode;
gAddBefore_t	gAddBefore = _gAddBefore;
gAddBodyPart_t	gAddBodyPart = _gAddBodyPart;
gAddDays_t	gAddDays = _gAddDays;
gAddFirst_t	gAddFirst = _gAddFirst;
gAddHeader_t	gAddHeader = _gAddHeader;
gAddHours_t	gAddHours = _gAddHours;
gAddInt_t	gAddInt = _gAddInt;
gAddLast_t	gAddLast = _gAddLast;
gAddMilliseconds_t	gAddMilliseconds = _gAddMilliseconds;
gAddMinutes_t	gAddMinutes = _gAddMinutes;
gAddMonths_t	gAddMonths = _gAddMonths;
gAddSeconds_t	gAddSeconds = _gAddSeconds;
gAddStr_t	gAddStr = _gAddStr;
gAddToPool_t	gAddToPool = _gAddToPool;
gAddValue_t	gAddValue = _gAddValue;
gAddYears_t	gAddYears = _gAddYears;
gAdvance_t	gAdvance = _gAdvance;
gAlloc_t	gAlloc = _gAlloc;
gAppend_t	gAppend = _gAppend;
gAppendChild_t	gAppendChild = _gAppendChild;
gApplyMask_t	gApplyMask = _gApplyMask;
gArgs_t	gArgs = _gArgs;
gArrayPointer_t	gArrayPointer = _gArrayPointer;
gAttributes_t	gAttributes = _gAttributes;
gBasicSize_t	gBasicSize = _gBasicSize;
gBlockingGetkey_t	gBlockingGetkey = _gBlockingGetkey;
gBufferSize_t	gBufferSize = _gBufferSize;
gCalToJul_t	gCalToJul = _gCalToJul;
gChangeCharAt_t	gChangeCharAt = _gChangeCharAt;
gChangeCharValue_t	gChangeCharValue = _gChangeCharValue;
gChangeDateTimeValues_t	gChangeDateTimeValues = _gChangeDateTimeValues;
gChangeDateValue_t	gChangeDateValue = _gChangeDateValue;
gChangeDoubleValue_t	gChangeDoubleValue = _gChangeDoubleValue;
gChangeFixedName_t	gChangeFixedName = _gChangeFixedName;
gChangeFunction_t	gChangeFunction = _gChangeFunction;
gChangeIntKey_t	gChangeIntKey = _gChangeIntKey;
gChangeKey_t	gChangeKey = _gChangeKey;
gChangeLongValue_t	gChangeLongValue = _gChangeLongValue;
gChangeName_t	gChangeName = _gChangeName;
gChangeNext_t	gChangeNext = _gChangeNext;
gChangePrevious_t	gChangePrevious = _gChangePrevious;
gChangePriority_t	gChangePriority = _gChangePriority;
gChangeRegisteredMemory_t	gChangeRegisteredMemory = _gChangeRegisteredMemory;
gChangeShortValue_t	gChangeShortValue = _gChangeShortValue;
gChangeStrValue_t	gChangeStrValue = _gChangeStrValue;
gChangeStringKey_t	gChangeStringKey = _gChangeStringKey;
gChangeTimeValue_t	gChangeTimeValue = _gChangeTimeValue;
gChangeToken_t	gChangeToken = _gChangeToken;
gChangeUShortValue_t	gChangeUShortValue = _gChangeUShortValue;
gChangeValue_t	gChangeValue = _gChangeValue;
gChangeValueWithInt_t	gChangeValueWithInt = _gChangeValueWithInt;
gChangeValueWithObj_t	gChangeValueWithObj = _gChangeValueWithObj;
gChangeValueWithStr_t	gChangeValueWithStr = _gChangeValueWithStr;
gCharValue_t	gCharValue = _gCharValue;
gCharValueAt_t	gCharValueAt = _gCharValueAt;
gChild_t	gChild = _gChild;
gCompare_t	gCompare = _gCompare;
gCompareI_t	gCompareI = _gCompareI;
gCompareN_t	gCompareN = _gCompareN;
gCompareNI_t	gCompareNI = _gCompareNI;
gCopy_t	gCopy = _gCopy;
gCount_t	gCount = _gCount;
gCreateAttribute_t	gCreateAttribute = _gCreateAttribute;
gCreateCDATASection_t	gCreateCDATASection = _gCreateCDATASection;
gCreateComment_t	gCreateComment = _gCreateComment;
gCreateElement_t	gCreateElement = _gCreateElement;
gCreateTextNode_t	gCreateTextNode = _gCreateTextNode;
gCurMemUsed_t	gCurMemUsed = _gCurMemUsed;
gDateTimeDifference_t	gDateTimeDifference = _gDateTimeDifference;
gDateTimeValues_t	gDateTimeValues = _gDateTimeValues;
gDateValue_t	gDateValue = _gDateValue;
gDayName_t	gDayName = _gDayName;
gDeepCopy_t	gDeepCopy = _gDeepCopy;
gDeepDispose_t	gDeepDispose = _gDeepDispose;
gDeepDisposeAllNodes_t	gDeepDisposeAllNodes = _gDeepDisposeAllNodes;
gDeepDisposeFirst_t	gDeepDisposeFirst = _gDeepDisposeFirst;
gDeepDisposeGroup_t	gDeepDisposeGroup = _gDeepDisposeGroup;
gDeepDisposeInt_t	gDeepDisposeInt = _gDeepDisposeInt;
gDeepDisposeLast_t	gDeepDisposeLast = _gDeepDisposeLast;
gDeepDisposeObj_t	gDeepDisposeObj = _gDeepDisposeObj;
gDeepDisposeStr_t	gDeepDisposeStr = _gDeepDisposeStr;
gDefaultRestart_t	gDefaultRestart = _gDefaultRestart;
gDeleteBTNode_t	gDeleteBTNode = _gDeleteBTNode;
gDifference_t	gDifference = _gDifference;
gDispose_t	gDispose = _gDispose;
gDispose1_t	gDispose1 = _gDispose1;
gDisposeAllNodes_t	gDisposeAllNodes = _gDisposeAllNodes;
gDisposeAllNodes1_t	gDisposeAllNodes1 = _gDisposeAllNodes1;
gDisposeAttribute_t	gDisposeAttribute = _gDisposeAttribute;
gDisposeFirst_t	gDisposeFirst = _gDisposeFirst;
gDisposeGlobalPool_t	gDisposeGlobalPool = _gDisposeGlobalPool;
gDisposeGroup_t	gDisposeGroup = _gDisposeGroup;
gDisposeInt_t	gDisposeInt = _gDisposeInt;
gDisposeItem_t	gDisposeItem = _gDisposeItem;
gDisposeLast_t	gDisposeLast = _gDisposeLast;
gDisposeObj_t	gDisposeObj = _gDisposeObj;
gDisposeObject_t	gDisposeObject = _gDisposeObject;
gDisposePropertyList_t	gDisposePropertyList = _gDisposePropertyList;
gDisposeStr_t	gDisposeStr = _gDisposeStr;
gDoesNotImplement_t	gDoesNotImplement = _gDoesNotImplement;
gDontCollect_t	gDontCollect = _gDontCollect;
gDoubleValue_t	gDoubleValue = _gDoubleValue;
gDrop_t	gDrop = _gDrop;
gDumpMemoryDiff_t	gDumpMemoryDiff = _gDumpMemoryDiff;
gDumpObjects_t	gDumpObjects = _gDumpObjects;
gDumpObjectsDiff_t	gDumpObjectsDiff = _gDumpObjectsDiff;
gDumpObjectsString_t	gDumpObjectsString = _gDumpObjectsString;
gDumpXML_t	gDumpXML = _gDumpXML;
gEndOfStream_t	gEndOfStream = _gEndOfStream;
gEnterCriticalSection_t	gEnterCriticalSection = _gEnterCriticalSection;
gEqual_t	gEqual = _gEqual;
gError_t	gError = _gError;
gException_t	gException = _gException;
gFileHandle_t	gFileHandle = _gFileHandle;
gFind_t	gFind = _gFind;
gFindAdd_t	gFindAdd = _gFindAdd;
gFindAddInt_t	gFindAddInt = _gFindAddInt;
gFindAddStr_t	gFindAddStr = _gFindAddStr;
gFindAddValue_t	gFindAddValue = _gFindAddValue;
gFindBTNEQ_t	gFindBTNEQ = _gFindBTNEQ;
gFindBTNFirst_t	gFindBTNFirst = _gFindBTNFirst;
gFindBTNGE_t	gFindBTNGE = _gFindBTNGE;
gFindBTNGT_t	gFindBTNGT = _gFindBTNGT;
gFindBTNLE_t	gFindBTNLE = _gFindBTNLE;
gFindBTNLT_t	gFindBTNLT = _gFindBTNLT;
gFindBTNLast_t	gFindBTNLast = _gFindBTNLast;
gFindChildNode_t	gFindChildNode = _gFindChildNode;
gFindChildNodeWithText_t	gFindChildNodeWithText = _gFindChildNodeWithText;
gFindClass_t	gFindClass = _gFindClass;
gFindEQ_t	gFindEQ = _gFindEQ;
gFindFirst_t	gFindFirst = _gFindFirst;
gFindGE_t	gFindGE = _gFindGE;
gFindGT_t	gFindGT = _gFindGT;
gFindGeneric_t	gFindGeneric = _gFindGeneric;
gFindInt_t	gFindInt = _gFindInt;
gFindLE_t	gFindLE = _gFindLE;
gFindLT_t	gFindLT = _gFindLT;
gFindLast_t	gFindLast = _gFindLast;
gFindMethod_t	gFindMethod = _gFindMethod;
gFindMethodObject_t	gFindMethodObject = _gFindMethodObject;
gFindNext_t	gFindNext = _gFindNext;
gFindNextNode_t	gFindNextNode = _gFindNextNode;
gFindNode_t	gFindNode = _gFindNode;
gFindPrev_t	gFindPrev = _gFindPrev;
gFindStr_t	gFindStr = _gFindStr;
gFindValue_t	gFindValue = _gFindValue;
gFindValueInt_t	gFindValueInt = _gFindValueInt;
gFindValueStr_t	gFindValueStr = _gFindValueStr;
gFirst_t	gFirst = _gFirst;
gFirstAttribute_t	gFirstAttribute = _gFirstAttribute;
gFixInvalidDate_t	gFixInvalidDate = _gFixInvalidDate;
gFlush_t	gFlush = _gFlush;
gFlushm_t	gFlushm = _gFlushm;
gForAll_t	gForAll = _gForAll;
gForceLineDirective_t	gForceLineDirective = _gForceLineDirective;
gFormatChar_t	gFormatChar = _gFormatChar;
gFormatDate_t	gFormatDate = _gFormatDate;
gFormatDateTime_t	gFormatDateTime = _gFormatDateTime;
gFormatNumber_t	gFormatNumber = _gFormatNumber;
gFormatTime_t	gFormatTime = _gFormatTime;
gFunction_t	gFunction = _gFunction;
gGC_t	gGC = _gGC;
gGCDispose_t	gGCDispose = _gGCDispose;
gGetAll_t	gGetAll = _gGetAll;
gGetAttribute_t	gGetAttribute = _gGetAttribute;
gGetAttributeValue_t	gGetAttributeValue = _gGetAttributeValue;
gGetBodyContent_t	gGetBodyContent = _gGetBodyContent;
gGetBodyParts_t	gGetBodyParts = _gGetBodyParts;
gGetBoundaryString_t	gGetBoundaryString = _gGetBoundaryString;
gGetCharFromNode_t	gGetCharFromNode = _gGetCharFromNode;
gGetCipher_t	gGetCipher = _gGetCipher;
gGetContentType_t	gGetContentType = _gGetContentType;
gGetErrorCode_t	gGetErrorCode = _gGetErrorCode;
gGetErrorStr_t	gGetErrorStr = _gGetErrorStr;
gGetFixedName_t	gGetFixedName = _gGetFixedName;
gGetFloatFromNode_t	gGetFloatFromNode = _gGetFloatFromNode;
gGetGenericPtr_t	gGetGenericPtr = _gGetGenericPtr;
gGetHeader_t	gGetHeader = _gGetHeader;
gGetHeaders_t	gGetHeaders = _gGetHeaders;
gGetIntFromNode_t	gGetIntFromNode = _gGetIntFromNode;
gGetMGName_t	gGetMGName = _gGetMGName;
gGetName_t	gGetName = _gGetName;
gGetParent_t	gGetParent = _gGetParent;
gGetPeerCertificateIssuerName_t	gGetPeerCertificateIssuerName = _gGetPeerCertificateIssuerName;
gGetPeerCertificateSubjectName_t	gGetPeerCertificateSubjectName = _gGetPeerCertificateSubjectName;
gGetSessionInfo_t	gGetSessionInfo = _gGetSessionInfo;
gGetStr_t	gGetStr = _gGetStr;
gGetTotalBytesRead_t	gGetTotalBytesRead = _gGetTotalBytesRead;
gGets_t	gGets = _gGets;
gGroupRemove_t	gGroupRemove = _gGroupRemove;
gHasInputArg_t	gHasInputArg = _gHasInputArg;
gHash_t	gHash = _gHash;
gHold_t	gHold = _gHold;
gHours_t	gHours = _gHours;
gHowManyBitsOfPeerPublicKey_t	gHowManyBitsOfPeerPublicKey = _gHowManyBitsOfPeerPublicKey;
gIPAddress_t	gIPAddress = _gIPAddress;
gIPAddressStr_t	gIPAddressStr = _gIPAddressStr;
gIncNelm_t	gIncNelm = _gIncNelm;
gIndex_t	gIndex = _gIndex;
gIndexOrigin_t	gIndexOrigin = _gIndexOrigin;
gInit_t	gInit = _gInit;
gInitLink_t	gInitLink = _gInitLink;
gInsertBefore_t	gInsertBefore = _gInsertBefore;
gInsertObjAt_t	gInsertObjAt = _gInsertObjAt;
gInstanceSize_t	gInstanceSize = _gInstanceSize;
gIntKey_t	gIntKey = _gIntKey;
gIntValue_t	gIntValue = _gIntValue;
gInvalidObject_t	gInvalidObject = _gInvalidObject;
gInvalidType_t	gInvalidType = _gInvalidType;
gIota_t	gIota = _gIota;
gIsKindOf_t	gIsKindOf = _gIsKindOf;
gIsVarArg_t	gIsVarArg = _gIsVarArg;
gJulToCal_t	gJulToCal = _gJulToCal;
gJulian_t	gJulian = _gJulian;
gJustifyCenter_t	gJustifyCenter = _gJustifyCenter;
gJustifyLeft_t	gJustifyLeft = _gJustifyLeft;
gJustifyRight_t	gJustifyRight = _gJustifyRight;
gKey_t	gKey = _gKey;
gKill_t	gKill = _gKill;
gLast_t	gLast = _gLast;
gLastArg_t	gLastArg = _gLastArg;
gLeaveCriticalSection_t	gLeaveCriticalSection = _gLeaveCriticalSection;
gLength_t	gLength = _gLength;
gLineHasColon_t	gLineHasColon = _gLineHasColon;
gLineNumber_t	gLineNumber = _gLineNumber;
gList_t	gList = _gList;
gLoadJavaClass_t	gLoadJavaClass = _gLoadJavaClass;
gLoadMask_t	gLoadMask = _gLoadMask;
gLock_t	gLock = _gLock;
gLongValue_t	gLongValue = _gLongValue;
gLookup_t	gLookup = _gLookup;
gMakeServer_t	gMakeServer = _gMakeServer;
gMarkMemoryBeginning_t	gMarkMemoryBeginning = _gMarkMemoryBeginning;
gMarkObject_t	gMarkObject = _gMarkObject;
gMarkRange_t	gMarkRange = _gMarkRange;
gMarkingMethod_t	gMarkingMethod = _gMarkingMethod;
gMaskFunction_t	gMaskFunction = _gMaskFunction;
gMatch_t	gMatch = _gMatch;
gMatchNoError_t	gMatchNoError = _gMatchNoError;
gMaxAfterGC_t	gMaxAfterGC = _gMaxAfterGC;
gMaxMemUsed_t	gMaxMemUsed = _gMaxMemUsed;
gMilliseconds_t	gMilliseconds = _gMilliseconds;
gMinutes_t	gMinutes = _gMinutes;
gMode_t	gMode = _gMode;
gMonthName_t	gMonthName = _gMonthName;
gMoreHandles_t	gMoreHandles = _gMoreHandles;
gMoveAfter_t	gMoveAfter = _gMoveAfter;
gMoveBefore_t	gMoveBefore = _gMoveBefore;
gMoveBeginning_t	gMoveBeginning = _gMoveBeginning;
gMoveEnd_t	gMoveEnd = _gMoveEnd;
gName_t	gName = _gName;
gNew_t	gNew = _gNew;
gNewArglist_t	gNewArglist = _gNewArglist;
gNewArray_t	gNewArray = _gNewArray;
gNewClass_t	gNewClass = _gNewClass;
gNewDateTime_t	gNewDateTime = _gNewDateTime;
gNewDocument_t	gNewDocument = _gNewDocument;
gNewFindFile_t	gNewFindFile = _gNewFindFile;
gNewGeneric_t	gNewGeneric = _gNewGeneric;
gNewGlobalPool_t	gNewGlobalPool = _gNewGlobalPool;
gNewGlobalPoolWithSize_t	gNewGlobalPoolWithSize = _gNewGlobalPoolWithSize;
gNewMethod_t	gNewMethod = _gNewMethod;
gNewMimeBodyPart_t	gNewMimeBodyPart = _gNewMimeBodyPart;
gNewMultipartMime_t	gNewMultipartMime = _gNewMultipartMime;
gNewNode_t	gNewNode = _gNewNode;
gNewSemaphore_t	gNewSemaphore = _gNewSemaphore;
gNewSetSeq_t	gNewSetSeq = _gNewSetSeq;
gNewStdClass_t	gNewStdClass = _gNewStdClass;
gNewThread_t	gNewThread = _gNewThread;
gNewToken_t	gNewToken = _gNewToken;
gNewWithChar_t	gNewWithChar = _gNewWithChar;
gNewWithDouble_t	gNewWithDouble = _gNewWithDouble;
gNewWithInt_t	gNewWithInt = _gNewWithInt;
gNewWithIntObj_t	gNewWithIntObj = _gNewWithIntObj;
gNewWithLong_t	gNewWithLong = _gNewWithLong;
gNewWithObj_t	gNewWithObj = _gNewWithObj;
gNewWithObjObj_t	gNewWithObjObj = _gNewWithObjObj;
gNewWithPtr_t	gNewWithPtr = _gNewWithPtr;
gNewWithStr_t	gNewWithStr = _gNewWithStr;
gNewWithStrInt_t	gNewWithStrInt = _gNewWithStrInt;
gNewWithStrObj_t	gNewWithStrObj = _gNewWithStrObj;
gNewWithStrStr_t	gNewWithStrStr = _gNewWithStrStr;
gNewWithStream_t	gNewWithStream = _gNewWithStream;
gNewWithUnsigned_t	gNewWithUnsigned = _gNewWithUnsigned;
gNext_t	gNext = _gNext;
gNextFile_t	gNextFile = _gNextFile;
gNextToken_t	gNextToken = _gNextToken;
gNow_t	gNow = _gNow;
gNth_t	gNth = _gNth;
gNumbGC_t	gNumbGC = _gNumbGC;
gNumbPieces_t	gNumbPieces = _gNumbPieces;
gObjectChecking_t	gObjectChecking = _gObjectChecking;
gObjectSerialNumber_t	gObjectSerialNumber = _gObjectSerialNumber;
gOpenFile_t	gOpenFile = _gOpenFile;
gOpenLowFile_t	gOpenLowFile = _gOpenLowFile;
gOpenStream2_t	gOpenStream2 = _gOpenStream2;
gOpenTempFile_t	gOpenTempFile = _gOpenTempFile;
gParameters_t	gParameters = _gParameters;
gParent_t	gParent = _gParent;
gParseFile_t	gParseFile = _gParseFile;
gParseMultipartFromString_t	gParseMultipartFromString = _gParseMultipartFromString;
gParseString_t	gParseString = _gParseString;
gPiece_t	gPiece = _gPiece;
gPointerValue_t	gPointerValue = _gPointerValue;
gPop_t	gPop = _gPop;
gPopulateStringFromNode_t	gPopulateStringFromNode = _gPopulateStringFromNode;
gPosition_t	gPosition = _gPosition;
gPrevious_t	gPrevious = _gPrevious;
gPrint_t	gPrint = _gPrint;
gPrintArgs_t	gPrintArgs = _gPrintArgs;
gPrintFixedArgs_t	gPrintFixedArgs = _gPrintFixedArgs;
gPrintLength_t	gPrintLength = _gPrintLength;
gPrintMethArgs_t	gPrintMethArgs = _gPrintMethArgs;
gPrintValue_t	gPrintValue = _gPrintValue;
gPrintVars_t	gPrintVars = _gPrintVars;
gPriority_t	gPriority = _gPriority;
gProcess_t	gProcess = _gProcess;
gPropertyGet_t	gPropertyGet = _gPropertyGet;
gPropertyPut_t	gPropertyPut = _gPropertyPut;
gPropertyRemove_t	gPropertyRemove = _gPropertyRemove;
gPropertySetAutoDispose_t	gPropertySetAutoDispose = _gPropertySetAutoDispose;
gPrototype_t	gPrototype = _gPrototype;
gProxyConnect_t	gProxyConnect = _gProxyConnect;
gPush_t	gPush = _gPush;
gPut_t	gPut = _gPut;
gPutc_t	gPutc = _gPutc;
gPutm_t	gPutm = _gPutm;
gPuts_t	gPuts = _gPuts;
gRank_t	gRank = _gRank;
gRead_t	gRead = _gRead;
gReadInt32_t	gReadInt32 = _gReadInt32;
gRecvFile_t	gRecvFile = _gRecvFile;
gRegisterMemory_t	gRegisterMemory = _gRegisterMemory;
gRelease_t	gRelease = _gRelease;
gReleaseSemaphore_t	gReleaseSemaphore = _gReleaseSemaphore;
gRemove_t	gRemove = _gRemove;
gRemoveAttribute_t	gRemoveAttribute = _gRemoveAttribute;
gRemoveFirst_t	gRemoveFirst = _gRemoveFirst;
gRemoveFromPool_t	gRemoveFromPool = _gRemoveFromPool;
gRemoveInt_t	gRemoveInt = _gRemoveInt;
gRemoveLast_t	gRemoveLast = _gRemoveLast;
gRemoveMask_t	gRemoveMask = _gRemoveMask;
gRemoveNode_t	gRemoveNode = _gRemoveNode;
gRemoveObj_t	gRemoveObj = _gRemoveObj;
gRemoveRegisteredMemory_t	gRemoveRegisteredMemory = _gRemoveRegisteredMemory;
gRemoveStr_t	gRemoveStr = _gRemoveStr;
gRemoveWaits_t	gRemoveWaits = _gRemoveWaits;
gResize_t	gResize = _gResize;
gResizeMethodCache_t	gResizeMethodCache = _gResizeMethodCache;
gRetreat_t	gRetreat = _gRetreat;
gReturnType_t	gReturnType = _gReturnType;
gRoom_t	gRoom = _gRoom;
gRound_t	gRound = _gRound;
gSLineDirective_t	gSLineDirective = _gSLineDirective;
gSaveXML_t	gSaveXML = _gSaveXML;
gSeconds_t	gSeconds = _gSeconds;
gSeek_t	gSeek = _gSeek;
gSendFile_t	gSendFile = _gSendFile;
gSendStr_t	gSendStr = _gSendStr;
gSequence_t	gSequence = _gSequence;
gSequenceLinks_t	gSequenceLinks = _gSequenceLinks;
gServerSocketConnect_t	gServerSocketConnect = _gServerSocketConnect;
gSetArgs_t	gSetArgs = _gSetArgs;
gSetAttribute_t	gSetAttribute = _gSetAttribute;
gSetErrorFunction_t	gSetErrorFunction = _gSetErrorFunction;
gSetFunction_t	gSetFunction = _gSetFunction;
gSetMaskFiller_t	gSetMaskFiller = _gSetMaskFiller;
gSetMemoryBufferArea_t	gSetMemoryBufferArea = _gSetMemoryBufferArea;
gSetMoreHandles_t	gSetMoreHandles = _gSetMoreHandles;
gSetNodeName_t	gSetNodeName = _gSetNodeName;
gSetNodeValue_t	gSetNodeValue = _gSetNodeValue;
gSetOSVars_t	gSetOSVars = _gSetOSVars;
gSetPropertyList_t	gSetPropertyList = _gSetPropertyList;
gSetTempSubDir_t	gSetTempSubDir = _gSetTempSubDir;
gSetTopNode_t	gSetTopNode = _gSetTopNode;
gShape_t	gShape = _gShape;
gShortValue_t	gShortValue = _gShortValue;
gShouldNotImplement_t	gShouldNotImplement = _gShouldNotImplement;
gSignal_t	gSignal = _gSignal;
gSize_t	gSize = _gSize;
gSocketConnect_t	gSocketConnect = _gSocketConnect;
gSpace_t	gSpace = _gSpace;
gStackAlloc_t	gStackAlloc = _gStackAlloc;
gState_t	gState = _gState;
gStringKey_t	gStringKey = _gStringKey;
gStringRep_t	gStringRep = _gStringRep;
gStringRepValue_t	gStringRepValue = _gStringRepValue;
gStringToXML_t	gStringToXML = _gStringToXML;
gStringValue_t	gStringValue = _gStringValue;
gStripCenter_t	gStripCenter = _gStripCenter;
gStripLeft_t	gStripLeft = _gStripLeft;
gStripRight_t	gStripRight = _gStripRight;
gSubClasses_t	gSubClasses = _gSubClasses;
gSubString_t	gSubString = _gSubString;
gSubclassResponsibility_t	gSubclassResponsibility = _gSubclassResponsibility;
gSuperClasses_t	gSuperClasses = _gSuperClasses;
gTLineDirective_t	gTLineDirective = _gTLineDirective;
gTake_t	gTake = _gTake;
gTimeDifference_t	gTimeDifference = _gTimeDifference;
gTimeStringRepValue_t	gTimeStringRepValue = _gTimeStringRepValue;
gTimeValue_t	gTimeValue = _gTimeValue;
gTimedRead_t	gTimedRead = _gTimedRead;
gTimedReadMS_t	gTimedReadMS = _gTimedReadMS;
gTimedWrite_t	gTimedWrite = _gTimedWrite;
gToLower_t	gToLower = _gToLower;
gToUpper_t	gToUpper = _gToUpper;
gToday_t	gToday = _gToday;
gToken_t	gToken = _gToken;
gTrace_t	gTrace = _gTrace;
gTracePrint_t	gTracePrint = _gTracePrint;
gTruncate_t	gTruncate = _gTruncate;
gType_t	gType = _gType;
gUnLock_t	gUnLock = _gUnLock;
gUnsignedShortValue_t	gUnsignedShortValue = _gUnsignedShortValue;
gUpdateLength_t	gUpdateLength = _gUpdateLength;
gUseStream_t	gUseStream = _gUseStream;
gUseVars_t	gUseVars = _gUseVars;
gValidDate_t	gValidDate = _gValidDate;
gValidDateTime_t	gValidDateTime = _gValidDateTime;
gValidTime_t	gValidTime = _gValidTime;
gValue_t	gValue = _gValue;
gVarArg_t	gVarArg = _gVarArg;
gWaitFor_t	gWaitFor = _gWaitFor;
gWaitSemaphore_t	gWaitSemaphore = _gWaitSemaphore;
gWrite_t	gWrite = _gWrite;
gWriteInt32_t	gWriteInt32 = _gWriteInt32;
gWriteTime_t	gWriteTime = _gWriteTime;
gXMLToString_t	gXMLToString = _gXMLToString;
gXPath_t	gXPath = _gXPath;
vBitValue_t	vBitValue = _vBitValue;
vBuild_t	vBuild = _vBuild;
vChangeBitValue_t	vChangeBitValue = _vChangeBitValue;
vChangeCharValue_t	vChangeCharValue = _vChangeCharValue;
vChangeDoubleValue_t	vChangeDoubleValue = _vChangeDoubleValue;
vChangeLongValue_t	vChangeLongValue = _vChangeLongValue;
vChangeShortValue_t	vChangeShortValue = _vChangeShortValue;
vChangeUShortValue_t	vChangeUShortValue = _vChangeUShortValue;
vChangeValue_t	vChangeValue = _vChangeValue;
vCharValue_t	vCharValue = _vCharValue;
vDoubleValue_t	vDoubleValue = _vDoubleValue;
vError_t	vError = _vError;
vGetValues_t	vGetValues = _vGetValues;
vLongValue_t	vLongValue = _vLongValue;
vMakeList_t	vMakeList = _vMakeList;
vNew_t	vNew = _vNew;
vPointerValue_t	vPointerValue = _vPointerValue;
vPrintf_t	vPrintf = _vPrintf;
vReshape_t	vReshape = _vReshape;
vShortValue_t	vShortValue = _vShortValue;
vSprintf_t	vSprintf = _vSprintf;
vUnsignedShortValue_t	vUnsignedShortValue = _vUnsignedShortValue;
vValue_t	vValue = _vValue;

void	InitGenerics()
{
	InitGeneric( gAccept );
	InitGeneric( gAdd );
	InitGeneric( gAddAfter );
	InitGeneric( gAddBTreeNode );
	InitGeneric( gAddBefore );
	InitGeneric( gAddBodyPart );
	InitGeneric( gAddDays );
	InitGeneric( gAddFirst );
	InitGeneric( gAddHeader );
	InitGeneric( gAddHours );
	InitGeneric( gAddInt );
	InitGeneric( gAddLast );
	InitGeneric( gAddMilliseconds );
	InitGeneric( gAddMinutes );
	InitGeneric( gAddMonths );
	InitGeneric( gAddSeconds );
	InitGeneric( gAddStr );
	InitGeneric( gAddToPool );
	InitGeneric( gAddValue );
	InitGeneric( gAddYears );
	InitGeneric( gAdvance );
	InitGeneric( gAlloc );
	InitGeneric( gAppend );
	InitGeneric( gAppendChild );
	InitGeneric( gApplyMask );
	InitGeneric( gArgs );
	InitGeneric( gArrayPointer );
	InitGeneric( gAttributes );
	InitGeneric( gBasicSize );
	InitGeneric( gBlockingGetkey );
	InitGeneric( gBufferSize );
	InitGeneric( gCalToJul );
	InitGeneric( gChangeCharAt );
	InitGeneric( gChangeCharValue );
	InitGeneric( gChangeDateTimeValues );
	InitGeneric( gChangeDateValue );
	InitGeneric( gChangeDoubleValue );
	InitGeneric( gChangeFixedName );
	InitGeneric( gChangeFunction );
	InitGeneric( gChangeIntKey );
	InitGeneric( gChangeKey );
	InitGeneric( gChangeLongValue );
	InitGeneric( gChangeName );
	InitGeneric( gChangeNext );
	InitGeneric( gChangePrevious );
	InitGeneric( gChangePriority );
	InitGeneric( gChangeRegisteredMemory );
	InitGeneric( gChangeShortValue );
	InitGeneric( gChangeStrValue );
	InitGeneric( gChangeStringKey );
	InitGeneric( gChangeTimeValue );
	InitGeneric( gChangeToken );
	InitGeneric( gChangeUShortValue );
	InitGeneric( gChangeValue );
	InitGeneric( gChangeValueWithInt );
	InitGeneric( gChangeValueWithObj );
	InitGeneric( gChangeValueWithStr );
	InitGeneric( gCharValue );
	InitGeneric( gCharValueAt );
	InitGeneric( gChild );
	InitGeneric( gCompare );
	InitGeneric( gCompareI );
	InitGeneric( gCompareN );
	InitGeneric( gCompareNI );
	InitGeneric( gCopy );
	InitGeneric( gCount );
	InitGeneric( gCreateAttribute );
	InitGeneric( gCreateCDATASection );
	InitGeneric( gCreateComment );
	InitGeneric( gCreateElement );
	InitGeneric( gCreateTextNode );
	InitGeneric( gCurMemUsed );
	InitGeneric( gDateTimeDifference );
	InitGeneric( gDateTimeValues );
	InitGeneric( gDateValue );
	InitGeneric( gDayName );
	InitGeneric( gDeepCopy );
	InitGeneric( gDeepDispose );
	InitGeneric( gDeepDisposeAllNodes );
	InitGeneric( gDeepDisposeFirst );
	InitGeneric( gDeepDisposeGroup );
	InitGeneric( gDeepDisposeInt );
	InitGeneric( gDeepDisposeLast );
	InitGeneric( gDeepDisposeObj );
	InitGeneric( gDeepDisposeStr );
	InitGeneric( gDefaultRestart );
	InitGeneric( gDeleteBTNode );
	InitGeneric( gDifference );
	InitGeneric( gDispose );
	InitGeneric( gDispose1 );
	InitGeneric( gDisposeAllNodes );
	InitGeneric( gDisposeAllNodes1 );
	InitGeneric( gDisposeAttribute );
	InitGeneric( gDisposeFirst );
	InitGeneric( gDisposeGlobalPool );
	InitGeneric( gDisposeGroup );
	InitGeneric( gDisposeInt );
	InitGeneric( gDisposeItem );
	InitGeneric( gDisposeLast );
	InitGeneric( gDisposeObj );
	InitGeneric( gDisposeObject );
	InitGeneric( gDisposePropertyList );
	InitGeneric( gDisposeStr );
	InitGeneric( gDoesNotImplement );
	InitGeneric( gDontCollect );
	InitGeneric( gDoubleValue );
	InitGeneric( gDrop );
	InitGeneric( gDumpMemoryDiff );
	InitGeneric( gDumpObjects );
	InitGeneric( gDumpObjectsDiff );
	InitGeneric( gDumpObjectsString );
	InitGeneric( gDumpXML );
	InitGeneric( gEndOfStream );
	InitGeneric( gEnterCriticalSection );
	InitGeneric( gEqual );
	InitGeneric( gError );
	InitGeneric( gException );
	InitGeneric( gFileHandle );
	InitGeneric( gFind );
	InitGeneric( gFindAdd );
	InitGeneric( gFindAddInt );
	InitGeneric( gFindAddStr );
	InitGeneric( gFindAddValue );
	InitGeneric( gFindBTNEQ );
	InitGeneric( gFindBTNFirst );
	InitGeneric( gFindBTNGE );
	InitGeneric( gFindBTNGT );
	InitGeneric( gFindBTNLE );
	InitGeneric( gFindBTNLT );
	InitGeneric( gFindBTNLast );
	InitGeneric( gFindChildNode );
	InitGeneric( gFindChildNodeWithText );
	InitGeneric( gFindClass );
	InitGeneric( gFindEQ );
	InitGeneric( gFindFirst );
	InitGeneric( gFindGE );
	InitGeneric( gFindGT );
	InitGeneric( gFindGeneric );
	InitGeneric( gFindInt );
	InitGeneric( gFindLE );
	InitGeneric( gFindLT );
	InitGeneric( gFindLast );
	InitGeneric( gFindMethod );
	InitGeneric( gFindMethodObject );
	InitGeneric( gFindNext );
	InitGeneric( gFindNextNode );
	InitGeneric( gFindNode );
	InitGeneric( gFindPrev );
	InitGeneric( gFindStr );
	InitGeneric( gFindValue );
	InitGeneric( gFindValueInt );
	InitGeneric( gFindValueStr );
	InitGeneric( gFirst );
	InitGeneric( gFirstAttribute );
	InitGeneric( gFixInvalidDate );
	InitGeneric( gFlush );
	InitGeneric( gFlushm );
	InitGeneric( gForAll );
	InitGeneric( gForceLineDirective );
	InitGeneric( gFormatChar );
	InitGeneric( gFormatDate );
	InitGeneric( gFormatDateTime );
	InitGeneric( gFormatNumber );
	InitGeneric( gFormatTime );
	InitGeneric( gFunction );
	InitGeneric( gGC );
	InitGeneric( gGCDispose );
	InitGeneric( gGetAll );
	InitGeneric( gGetAttribute );
	InitGeneric( gGetAttributeValue );
	InitGeneric( gGetBodyContent );
	InitGeneric( gGetBodyParts );
	InitGeneric( gGetBoundaryString );
	InitGeneric( gGetCharFromNode );
	InitGeneric( gGetCipher );
	InitGeneric( gGetContentType );
	InitGeneric( gGetErrorCode );
	InitGeneric( gGetErrorStr );
	InitGeneric( gGetFixedName );
	InitGeneric( gGetFloatFromNode );
	InitGeneric( gGetGenericPtr );
	InitGeneric( gGetHeader );
	InitGeneric( gGetHeaders );
	InitGeneric( gGetIntFromNode );
	InitGeneric( gGetMGName );
	InitGeneric( gGetName );
	InitGeneric( gGetParent );
	InitGeneric( gGetPeerCertificateIssuerName );
	InitGeneric( gGetPeerCertificateSubjectName );
	InitGeneric( gGetSessionInfo );
	InitGeneric( gGetStr );
	InitGeneric( gGetTotalBytesRead );
	InitGeneric( gGets );
	InitGeneric( gGroupRemove );
	InitGeneric( gHasInputArg );
	InitGeneric( gHash );
	InitGeneric( gHold );
	InitGeneric( gHours );
	InitGeneric( gHowManyBitsOfPeerPublicKey );
	InitGeneric( gIPAddress );
	InitGeneric( gIPAddressStr );
	InitGeneric( gIncNelm );
	InitGeneric( gIndex );
	InitGeneric( gIndexOrigin );
	InitGeneric( gInit );
	InitGeneric( gInitLink );
	InitGeneric( gInsertBefore );
	InitGeneric( gInsertObjAt );
	InitGeneric( gInstanceSize );
	InitGeneric( gIntKey );
	InitGeneric( gIntValue );
	InitGeneric( gInvalidObject );
	InitGeneric( gInvalidType );
	InitGeneric( gIota );
	InitGeneric( gIsKindOf );
	InitGeneric( gIsVarArg );
	InitGeneric( gJulToCal );
	InitGeneric( gJulian );
	InitGeneric( gJustifyCenter );
	InitGeneric( gJustifyLeft );
	InitGeneric( gJustifyRight );
	InitGeneric( gKey );
	InitGeneric( gKill );
	InitGeneric( gLast );
	InitGeneric( gLastArg );
	InitGeneric( gLeaveCriticalSection );
	InitGeneric( gLength );
	InitGeneric( gLineHasColon );
	InitGeneric( gLineNumber );
	InitGeneric( gList );
	InitGeneric( gLoadJavaClass );
	InitGeneric( gLoadMask );
	InitGeneric( gLock );
	InitGeneric( gLongValue );
	InitGeneric( gLookup );
	InitGeneric( gMakeServer );
	InitGeneric( gMarkMemoryBeginning );
	InitGeneric( gMarkObject );
	InitGeneric( gMarkRange );
	InitGeneric( gMarkingMethod );
	InitGeneric( gMaskFunction );
	InitGeneric( gMatch );
	InitGeneric( gMatchNoError );
	InitGeneric( gMaxAfterGC );
	InitGeneric( gMaxMemUsed );
	InitGeneric( gMilliseconds );
	InitGeneric( gMinutes );
	InitGeneric( gMode );
	InitGeneric( gMonthName );
	InitGeneric( gMoreHandles );
	InitGeneric( gMoveAfter );
	InitGeneric( gMoveBefore );
	InitGeneric( gMoveBeginning );
	InitGeneric( gMoveEnd );
	InitGeneric( gName );
	InitGeneric( gNewArglist );
	InitGeneric( gNewArray );
	InitGeneric( gNewDateTime );
	InitGeneric( gNewDocument );
	InitGeneric( gNewFindFile );
	InitGeneric( gNewGlobalPool );
	InitGeneric( gNewGlobalPoolWithSize );
	InitGeneric( gNewMimeBodyPart );
	InitGeneric( gNewMultipartMime );
	InitGeneric( gNewNode );
	InitGeneric( gNewSemaphore );
	InitGeneric( gNewSetSeq );
	InitGeneric( gNewStdClass );
	InitGeneric( gNewThread );
	InitGeneric( gNewToken );
	InitGeneric( gNewWithChar );
	InitGeneric( gNewWithDouble );
	InitGeneric( gNewWithInt );
	InitGeneric( gNewWithIntObj );
	InitGeneric( gNewWithLong );
	InitGeneric( gNewWithObj );
	InitGeneric( gNewWithObjObj );
	InitGeneric( gNewWithPtr );
	InitGeneric( gNewWithStr );
	InitGeneric( gNewWithStrInt );
	InitGeneric( gNewWithStrObj );
	InitGeneric( gNewWithStrStr );
	InitGeneric( gNewWithStream );
	InitGeneric( gNewWithUnsigned );
	InitGeneric( gNext );
	InitGeneric( gNextFile );
	InitGeneric( gNextToken );
	InitGeneric( gNow );
	InitGeneric( gNth );
	InitGeneric( gNumbGC );
	InitGeneric( gNumbPieces );
	InitGeneric( gObjectChecking );
	InitGeneric( gObjectSerialNumber );
	InitGeneric( gOpenFile );
	InitGeneric( gOpenLowFile );
	InitGeneric( gOpenStream2 );
	InitGeneric( gOpenTempFile );
	InitGeneric( gParameters );
	InitGeneric( gParent );
	InitGeneric( gParseFile );
	InitGeneric( gParseMultipartFromString );
	InitGeneric( gParseString );
	InitGeneric( gPiece );
	InitGeneric( gPointerValue );
	InitGeneric( gPop );
	InitGeneric( gPopulateStringFromNode );
	InitGeneric( gPosition );
	InitGeneric( gPrevious );
	InitGeneric( gPrint );
	InitGeneric( gPrintArgs );
	InitGeneric( gPrintFixedArgs );
	InitGeneric( gPrintLength );
	InitGeneric( gPrintMethArgs );
	InitGeneric( gPrintValue );
	InitGeneric( gPrintVars );
	InitGeneric( gPriority );
	InitGeneric( gProcess );
	InitGeneric( gPropertyGet );
	InitGeneric( gPropertyPut );
	InitGeneric( gPropertyRemove );
	InitGeneric( gPropertySetAutoDispose );
	InitGeneric( gPrototype );
	InitGeneric( gProxyConnect );
	InitGeneric( gPush );
	InitGeneric( gPut );
	InitGeneric( gPutc );
	InitGeneric( gPutm );
	InitGeneric( gPuts );
	InitGeneric( gRank );
	InitGeneric( gRead );
	InitGeneric( gReadInt32 );
	InitGeneric( gRecvFile );
	InitGeneric( gRegisterMemory );
	InitGeneric( gRelease );
	InitGeneric( gReleaseSemaphore );
	InitGeneric( gRemove );
	InitGeneric( gRemoveAttribute );
	InitGeneric( gRemoveFirst );
	InitGeneric( gRemoveFromPool );
	InitGeneric( gRemoveInt );
	InitGeneric( gRemoveLast );
	InitGeneric( gRemoveMask );
	InitGeneric( gRemoveNode );
	InitGeneric( gRemoveObj );
	InitGeneric( gRemoveRegisteredMemory );
	InitGeneric( gRemoveStr );
	InitGeneric( gRemoveWaits );
	InitGeneric( gResize );
	InitGeneric( gResizeMethodCache );
	InitGeneric( gRetreat );
	InitGeneric( gReturnType );
	InitGeneric( gRoom );
	InitGeneric( gRound );
	InitGeneric( gSLineDirective );
	InitGeneric( gSaveXML );
	InitGeneric( gSeconds );
	InitGeneric( gSeek );
	InitGeneric( gSendFile );
	InitGeneric( gSendStr );
	InitGeneric( gSequence );
	InitGeneric( gSequenceLinks );
	InitGeneric( gServerSocketConnect );
	InitGeneric( gSetArgs );
	InitGeneric( gSetAttribute );
	InitGeneric( gSetErrorFunction );
	InitGeneric( gSetFunction );
	InitGeneric( gSetMaskFiller );
	InitGeneric( gSetMemoryBufferArea );
	InitGeneric( gSetMoreHandles );
	InitGeneric( gSetNodeName );
	InitGeneric( gSetNodeValue );
	InitGeneric( gSetOSVars );
	InitGeneric( gSetPropertyList );
	InitGeneric( gSetTempSubDir );
	InitGeneric( gSetTopNode );
	InitGeneric( gShape );
	InitGeneric( gShortValue );
	InitGeneric( gShouldNotImplement );
	InitGeneric( gSignal );
	InitGeneric( gSize );
	InitGeneric( gSocketConnect );
	InitGeneric( gSpace );
	InitGeneric( gStackAlloc );
	InitGeneric( gState );
	InitGeneric( gStringKey );
	InitGeneric( gStringRep );
	InitGeneric( gStringRepValue );
	InitGeneric( gStringToXML );
	InitGeneric( gStringValue );
	InitGeneric( gStripCenter );
	InitGeneric( gStripLeft );
	InitGeneric( gStripRight );
	InitGeneric( gSubClasses );
	InitGeneric( gSubString );
	InitGeneric( gSubclassResponsibility );
	InitGeneric( gSuperClasses );
	InitGeneric( gTLineDirective );
	InitGeneric( gTake );
	InitGeneric( gTimeDifference );
	InitGeneric( gTimeStringRepValue );
	InitGeneric( gTimeValue );
	InitGeneric( gTimedRead );
	InitGeneric( gTimedReadMS );
	InitGeneric( gTimedWrite );
	InitGeneric( gToLower );
	InitGeneric( gToUpper );
	InitGeneric( gToday );
	InitGeneric( gToken );
	InitGeneric( gTrace );
	InitGeneric( gTracePrint );
	InitGeneric( gTruncate );
	InitGeneric( gType );
	InitGeneric( gUnLock );
	InitGeneric( gUnsignedShortValue );
	InitGeneric( gUpdateLength );
	InitGeneric( gUseStream );
	InitGeneric( gUseVars );
	InitGeneric( gValidDate );
	InitGeneric( gValidDateTime );
	InitGeneric( gValidTime );
	InitGeneric( gValue );
	InitGeneric( gVarArg );
	InitGeneric( gWaitFor );
	InitGeneric( gWaitSemaphore );
	InitGeneric( gWrite );
	InitGeneric( gWriteInt32 );
	InitGeneric( gWriteTime );
	InitGeneric( gXMLToString );
	InitGeneric( gXPath );
	InitGeneric( vBitValue );
	InitGeneric( vBuild );
	InitGeneric( vChangeBitValue );
	InitGeneric( vChangeCharValue );
	InitGeneric( vChangeDoubleValue );
	InitGeneric( vChangeLongValue );
	InitGeneric( vChangeShortValue );
	InitGeneric( vChangeUShortValue );
	InitGeneric( vChangeValue );
	InitGeneric( vCharValue );
	InitGeneric( vDoubleValue );
	InitGeneric( vError );
	InitGeneric( vGetValues );
	InitGeneric( vLongValue );
	InitGeneric( vMakeList );
	InitGeneric( vNew );
	InitGeneric( vPointerValue );
	InitGeneric( vPrintf );
	InitGeneric( vReshape );
	InitGeneric( vShortValue );
	InitGeneric( vSprintf );
	InitGeneric( vUnsignedShortValue );
	InitGeneric( vValue );
}

void	InitDynace(void *s)
{
	int	nClasses = 80;

	InitKernel(s, nClasses*2);

}

#ifdef	__cplusplus
}
#endif

redpajama_set_name: RedPajamaGithub