//¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬
//

#include "stdafx.h"

//¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬
//
#include <Define.h>
#include "CPShowMSG.h"
#include <Protocol_CG.h>
#include <Protocol_CW.h>
//
//¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬
//
#include "../Protocol_CG.HEAD.h"
#include "../Protocol_CG.WRAP.h"
#include "../Protocol_CW.WRAP.h"
#include "../Protocol_CG.TAIL.h"
//
//¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬


//¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬
#if		CPSHOWLIB_VERSION == 0x0200
//¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬


//¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡
//	(Internal Interfaces)
struct CPShowLIB
{
	static INT			Init( BYTE verMAJOR, BYTE verMIDDLE, DWORD oddNOcate, DWORD oddNOproto );
	static const CHAR*	Query( BYTE byCategory, BYTE byProtocol, DWORD* dwOffset );
};

//¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡
//	(Interfaces)
static const CPShowFNTable		s_CPShowHandler	= { &CPShowLIB::Init, &CPShowLIB::Query };
static const CPShowFNTable*		s_CPShowMSG		= NULL;

//¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡
//
const CPShowFNTable*
GetCPShowHandler()
{
	if( s_CPShowMSG )
		return s_CPShowMSG;

	s_CPShowMSG = &s_CPShowHandler;
	return s_CPShowMSG;
}


//¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡
//
INT
CPShowLIB::Init( BYTE verMAJOR, BYTE verMIDDLE, DWORD oddNOcate, DWORD oddNOproto )
{
	const BOOLEAN bAccept
		=  (C2S_HIGH_VERSION_NO == verMAJOR)
		&& (C2S_MIDDLE_VERSION_NO == verMIDDLE)
		&& (CATEGORY_ODD_NUMBER == oddNOcate)
		&& (PROTOCOL_ODD_NUMBER == oddNOproto)
		;

	return bAccept
		?	0
		:	ERR_CPSHOW_DIFFVERSION
		;
}


//¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡
//
const CHAR*
CPShowLIB::Query( BYTE byCategory, BYTE byProtocol, DWORD* dwOffset )
{
	const BOOLEAN bound_over
		=  ((DWORD)byCategory > 256)
		|| ((DWORD)byProtocol > 256)
		;

	if( bound_over )
		return NULL;

	const CHAR* pCategoryName = NULL;
	const CHAR* pProtocolName = NULL;

	DWORD countC = 0;
	const PROTOCOL_STRUCT_CATEINDEX* const pItConst = &idxCG_CATEGORY[0];
	const PROTOCOL_STRUCT_CATEINDEX* pIt = pItConst;
	for( ; countC<256 ; ++countC, ++pIt )
	{
		if( !pIt->pProtocols )
			break;

		const BYTE category = (BYTE)pIt->dwIndex;
		if( category != byCategory )
			continue;

		pCategoryName = pIt->pCategoryName;

		const PROTOCOL_STRUCT* pProtocol = pIt->pProtocols;
		DWORD countP = 0;
		for( ; countP<256 ; ++countP, ++pProtocol )
		{
			if( !pProtocol->name )
				break;

			if( pProtocol->code != byProtocol )
				continue;

			pProtocolName = pProtocol->name;
			break;
		}

		break;
	}

	return
		pProtocolName	?		pProtocolName
		: pCategoryName	?		pCategoryName
		:						NULL
		;
}


//¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬
#elif	CPSHOWLIB_VERSION == 0x0100
//¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬

#include <vector>
#include <list>

using namespace std;

#include <crtdbg.h>
#include <assert.h>

//¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡
//	<Prototypes>
static INT		Init( BYTE verMAJOR, BYTE verMIDDLE, DWORD oddNOcate, DWORD oddNOproto );
static const CHAR*	Query( BYTE byCategory, BYTE byProtocol, DWORD* dwOffset );

//
//¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡
//
const static CPShowFNTable* s_CPShowMSG = NULL;
const static CPShowFNTable s_CPShowHandler = { &Init, &Query };
//
const CPShowFNTable* GetCPShowHandler()
{
	if( s_CPShowMSG )
		return s_CPShowMSG;

	s_CPShowMSG = &s_CPShowHandler;
	return s_CPShowMSG;
}
//
//========================================================

//#define INDEX_SIZE		512
#define INDEX_SIZE		2048
#define GET_KEY(wKey)	((WORD)(wKey/29) % INDEX_SIZE)
//#define GET_KEY(wKey)	((WORD)(wKey/4) % INDEX_SIZE)

#ifdef __CPSHOW_UNUSED_SECT__
static BYTE pCATEGORY_OFFSETs[256] = { 0, };
static BYTE pPROTOCOL_OFFSETs[256] = { 0, };
static BYTE pCATEGORY_BOUNDs[10] = { 0, };	// ÀÌÈÄ AG, DG, AW, CW µîµî¿¡ ´ëÇÑ º¸¿ÏÀ» °í·ÁÇÏÀÚ.
static BYTE pPROTOCOL_BOUNDs[256] = { 0, };
#endif

//
struct SListTable
{
	WORD	wUKey;
	CHAR*	name;
};

struct SIndexTable
{
	SListTable* pList;
	DWORD		dwCount;
};

static DWORD ListTableLength = 0;
static SListTable* pListTable = NULL;
static SIndexTable IndexTable[INDEX_SIZE] = { NULL, };
//

static VOID		_Init_CategoryIndex();
static VOID		_Init_ProtocolIndex();
static INT		_Process();

static INT		_MAKETABLE();
static INT		Init( BYTE verMAJOR, BYTE verMIDDLE, DWORD oddNOcate, DWORD oddNOproto )
{
	BOOL bChk = FALSE;

	if( C2S_HIGH_VERSION_NO == verMAJOR )
		if( C2S_MIDDLE_VERSION_NO == verMIDDLE )
			if( CATEGORY_ODD_NUMBER == oddNOcate )
				if( PROTOCOL_ODD_NUMBER == oddNOproto )
					bChk = TRUE;

	if( !bChk )
		return ERR_CPSHOW_DIFFVERSION;

#ifdef __CPSHOW_UNUSED_SECT__
	_Init_CategoryIndex();
	_Init_ProtocolIndex();
	//_Process();
#endif
	return _MAKETABLE();
}

static INT		_MAKETABLE()
{
	typedef pair<WORD, PROTOCOL_STRUCT*>		CPSHOW_PAIR;
	typedef list<CPSHOW_PAIR>					CPSHOW_DLIST;
	typedef list<CPSHOW_PAIR>::iterator			CPSHOW_DLIST_IT;
	typedef vector<CPSHOW_DLIST*>				CPSHOW_CLIST;

	CPSHOW_CLIST cateLIST;
	cateLIST.reserve( INDEX_SIZE );

	for( int i=0 ; i<INDEX_SIZE ; ++i )
	{
		CPSHOW_DLIST* p_dLIST = new CPSHOW_DLIST;
		cateLIST[i] = p_dLIST;
	}

	int iCount;
	int iSum = 0;

	const PROTOCOL_STRUCT_CATEINDEX* pPTR = &idxCG_CATEGORY[0];
	for( iCount=0 ; iCount<256 ; ++iCount )
	{
		if( pPTR->pProtocols == NULL )
			break;

		BYTE byCateNo = (BYTE)pPTR->dwIndex;
		const PROTOCOL_STRUCT* pProtocols = pPTR->pProtocols;

		int iSubCount = 0;
		for( ; iSubCount<256 ; ++iSubCount )
		{
			if( pProtocols->name == NULL )
				break;

			BYTE byProtoNo = pProtocols->code;
			WORD wKey = MAKEWORD(byCateNo, byProtoNo);

			WORD wUKey = GET_KEY(wKey);// (WORD)(wKey/29) % INDEX_SIZE;
			CPSHOW_DLIST& dList = *cateLIST[wUKey];

			cateLIST[wUKey]->insert( cateLIST[wUKey]->end(), CPSHOW_PAIR(wKey, (PROTOCOL_STRUCT*)pProtocols));

			pProtocols++;
		}

		if( !(iSubCount < 256) )
		{
			printf( "Error : IndexOutOfRange Protocol Count\n" );
		}
		else
		{
			iSum += iSubCount;
		}

		pPTR++;
	}

	if( !(iCount < 256) )
	{
		printf( "Error : IndexOutOfRange Protocol Count\n" );
		return ERR_CPSHOW_FAULT;
	}

	//static DWORD ListTableLength = 0;
	//static SListTable* pListTable = NULL;
	//static SIndexTable IndexTable[256] = { NULL, };
	ListTableLength = (DWORD)iSum;
	pListTable = (SListTable*)malloc( sizeof(SListTable)*ListTableLength );

#ifdef __DEBUG_TESTUNIT__
	////////////////////////////////////////////////////////////////////////////
	// <test code>
	BYTE bylists[INDEX_SIZE] = { 0, };
	for( iCount=0 ; iCount<INDEX_SIZE ; ++iCount )
	{
		CPSHOW_DLIST& rDLIST = *cateLIST[iCount];
		bylists[iCount] = (BYTE)rDLIST.size();
	}
	FILE* pFILE = fopen( "list.txt", "w+" );
	CHAR strmsg[20];
	for( iCount=0 ; iCount<INDEX_SIZE ; ++iCount )
	{
		_snprintf( strmsg, 20, "%03d\t%d\n", iCount, bylists[iCount] );
		fputs( strmsg, pFILE );
	}
	fflush(pFILE);
	fclose(pFILE);
	// <test code>
	////////////////////////////////////////////////////////////////////////////
#endif //__DEBUG_TESTUNIT__

	SListTable* pListOffset = pListTable;
	for( iCount=0 ; iCount<INDEX_SIZE ; ++iCount )
	{
		CPSHOW_DLIST& rDLIST = *cateLIST[iCount];
		//DWORD dwSize = rDLIST.size();

		IndexTable[iCount].pList = pListOffset;

		CPSHOW_DLIST_IT it(rDLIST.begin()), end(rDLIST.end());
		DWORD dwIdx=0;
		for( ; it != end ; ++it )
		{
			WORD wUKey = it->first;
			PROTOCOL_STRUCT* pProtocol = it->second;
			pListOffset->wUKey = wUKey;
			pListOffset->name = pProtocol->name;
			++pListOffset;
			++dwIdx;
		}
		IndexTable[iCount].dwCount = dwIdx;
	}

	for( int i=0 ; i<INDEX_SIZE ; ++i )
	{
		delete cateLIST[i];
	}

	return ListTableLength;
}

static const CHAR*	Query( BYTE byCategory, BYTE byProtocol, DWORD* dwOffset )
{
	if( (DWORD)byCategory > 256 || (DWORD)byProtocol > 256 )
		return NULL;

	WORD wKey = MAKEWORD(byCategory, byProtocol);
	WORD wUKey = GET_KEY(wKey);

	//static DWORD ListTableLength = 0;
	//static SListTable* pListTable = NULL;
	//static SIndexTable IndexTable[256] = { NULL, };

	DWORD dwFind = 0;

	DWORD dwSize = IndexTable[wUKey].dwCount;
	SListTable* pList = IndexTable[wUKey].pList;
	for( dwFind=0 ; dwFind<dwSize ; ++dwFind )
	{
		if( wKey == pList->wUKey )
		{
			if( dwOffset )
			{
				*dwOffset = (DWORD)( ((DWORD)(__int64)pList - (DWORD)(__int64)&IndexTable[0])/sizeof(SListTable) );
			}
			return pList->name;
		}

		++pList;
	}

	return NULL;

	/*
	if( !(byCategory < 256 && byProtocol < 256) )
	{
		// error
		return NULL;
	}

	DWORD upperbound = pCATEGORY_BOUNDs[0];
	DWORD dwIndex = pCATEGORY_OFFSETs[byCategory];

	if( !(dwIndex < upperbound) )
		return NULL;

	const PROTOCOL_STRUCT_CATEINDEX* pPTR = &idxCG_CATEGORY[dwIndex];
	const PROTOCOL_STRUCT* pProtocols = pPTR->pProtocols;

	DWORD dwProtoIndex = pPROTOCOL_OFFSETs[byProtocol];
	DWORD proto_upperbound = pPROTOCOL_BOUNDs[dwProtoIndex];

	if( !(dwProtoIndex < proto_upperbound) )
		return NULL;

	return pProtocols[dwProtoIndex].name;
	*/

/*
	// ÀÌÀü ¹öÀü¿ë
	if( (DWORD)byCategory > 256 || (DWORD)byProtocol > 256 )
		return NULL;

	int iFind = 0;
	const PROTOCOL_STRUCT_CATEINDEX* pPTR = &idxCG_CATEGORY[0];
	for(  ; iFind<256 ; ++iFind )
	{
		if( pPTR->pProtocols == NULL )
		{
			iFind = 256;
			break;
		}

		if( pPTR->dwIndex == byCategory )
			break;

		pPTR++;
	}

	if( iFind==256 )
	{
		//perror( "Can't find Category Number" );
		return NULL;
	}

	CHAR* catename = pPTR->pCategoryName;
	const PROTOCOL_STRUCT* pProtocols = pPTR->pProtocols;

	for( iFind=0 ; iFind<256 ; ++iFind )
	{
		if( pProtocols->name == NULL )
		{
			iFind = 256;
			break;
		}

		if( pProtocols->code == (BYTE)byProtocol )
			break;

		pProtocols++;
	}

	return pProtocols->name;
*/
}

#ifdef __CPSHOW_UNUSED_SECT__

static VOID		_Init_CategoryIndex()
{
	DWORD dwIndex = 0;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_001	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_002	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_003	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_004	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_005	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_006	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_007	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_008	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_009	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_010	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_011	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_012	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_013	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_014	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_015	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_016	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_017	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_018	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_019	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_020	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_021	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_022	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_023	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_024	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_025	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_026	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_027	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_028	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_029	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_030	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_031	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_032	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_033	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_034	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_035	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_036	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_037	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_038	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_039	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_040	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_041	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_042	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_043	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_044	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_045	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_046	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_047	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_048	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_049	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_050	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_051	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_052	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_053	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_054	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_055	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_056	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_057	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_058	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_059	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_060	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_061	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_062	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_063	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_064	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_065	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_066	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_067	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_068	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_069	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_070	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_071	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_072	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_073	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_074	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_075	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_076	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_077	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_078	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_079	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_080	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_081	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_082	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_083	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_084	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_085	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_086	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_087	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_088	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_089	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_090	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_091	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_092	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_093	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_094	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_095	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_096	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_097	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_098	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_099	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_100	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_101	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_102	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_103	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_104	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_105	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_106	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_107	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_108	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_109	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_110	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_111	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_112	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_113	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_114	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_115	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_116	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_117	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_118	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_119	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_120	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_121	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_122	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_123	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_124	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_125	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_126	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_127	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_128	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_129	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_130	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_131	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_132	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_133	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_134	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_135	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_136	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_137	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_138	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_139	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_140	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_141	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_142	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_143	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_144	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_145	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_146	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_147	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_148	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_149	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_150	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_151	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_152	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_153	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_154	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_155	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_156	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_157	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_158	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_159	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_160	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_161	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_162	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_163	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_164	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_165	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_166	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_167	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_168	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_169	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_170	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_171	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_172	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_173	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_174	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_175	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_176	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_177	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_178	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_179	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_180	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_181	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_182	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_183	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_184	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_185	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_186	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_187	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_188	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_189	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_190	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_191	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_192	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_193	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_194	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_195	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_196	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_197	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_198	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_199	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_200	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_201	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_202	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_203	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_204	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_205	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_206	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_207	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_208	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_209	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_210	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_211	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_212	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_213	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_214	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_215	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_216	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_217	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_218	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_219	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_220	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_221	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_222	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_223	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_224	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_225	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_226	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_227	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_228	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_229	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_230	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_231	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_232	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_233	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_234	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_235	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_236	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_237	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_238	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_239	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_240	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_241	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_242	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_243	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_244	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_245	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_246	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_247	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_248	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_249	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_250	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_251	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_252	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_253	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_254	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_255	] = (BYTE)dwIndex++;
	pCATEGORY_OFFSETs[	CATEGORY_GENERATOR_256	] = (BYTE)dwIndex++;
}

static VOID		_Init_ProtocolIndex()
{
	DWORD dwIndex = 0;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_001	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_002	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_003	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_004	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_005	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_006	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_007	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_008	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_009	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_010	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_011	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_012	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_013	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_014	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_015	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_016	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_017	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_018	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_019	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_020	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_021	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_022	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_023	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_024	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_025	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_026	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_027	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_028	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_029	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_030	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_031	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_032	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_033	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_034	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_035	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_036	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_037	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_038	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_039	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_040	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_041	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_042	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_043	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_044	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_045	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_046	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_047	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_048	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_049	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_050	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_051	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_052	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_053	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_054	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_055	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_056	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_057	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_058	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_059	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_060	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_061	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_062	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_063	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_064	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_065	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_066	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_067	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_068	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_069	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_070	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_071	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_072	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_073	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_074	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_075	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_076	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_077	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_078	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_079	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_080	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_081	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_082	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_083	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_084	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_085	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_086	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_087	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_088	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_089	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_090	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_091	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_092	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_093	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_094	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_095	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_096	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_097	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_098	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_099	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_100	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_101	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_102	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_103	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_104	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_105	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_106	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_107	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_108	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_109	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_110	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_111	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_112	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_113	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_114	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_115	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_116	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_117	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_118	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_119	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_120	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_121	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_122	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_123	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_124	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_125	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_126	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_127	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_128	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_129	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_130	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_131	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_132	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_133	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_134	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_135	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_136	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_137	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_138	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_139	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_140	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_141	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_142	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_143	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_144	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_145	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_146	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_147	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_148	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_149	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_150	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_151	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_152	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_153	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_154	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_155	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_156	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_157	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_158	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_159	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_160	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_161	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_162	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_163	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_164	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_165	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_166	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_167	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_168	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_169	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_170	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_171	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_172	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_173	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_174	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_175	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_176	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_177	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_178	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_179	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_180	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_181	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_182	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_183	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_184	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_185	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_186	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_187	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_188	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_189	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_190	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_191	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_192	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_193	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_194	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_195	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_196	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_197	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_198	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_199	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_200	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_201	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_202	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_203	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_204	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_205	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_206	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_207	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_208	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_209	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_210	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_211	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_212	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_213	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_214	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_215	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_216	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_217	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_218	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_219	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_220	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_221	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_222	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_223	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_224	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_225	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_226	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_227	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_228	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_229	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_230	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_231	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_232	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_233	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_234	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_235	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_236	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_237	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_238	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_239	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_240	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_241	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_242	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_243	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_244	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_245	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_246	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_247	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_248	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_249	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_250	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_251	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_252	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_253	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_254	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_255	] = (BYTE)dwIndex++;
	pPROTOCOL_OFFSETs[	PROTOCOL_GENERATOR_256	] = (BYTE)dwIndex++;
}


static INT		_Process()
{
	int iCount;
	int iSum = 0;
	const PROTOCOL_STRUCT_CATEINDEX* pPTR = &idxCG_CATEGORY[0];
	for( iCount=0 ; iCount<256 ; ++iCount )
	{
		if( pPTR->pProtocols == NULL )
			break;

		BYTE byCateNo = (BYTE)pPTR->dwIndex;
		const PROTOCOL_STRUCT* pProtocols = pPTR->pProtocols;

		int iSubCount = 0;
		for( ; iSubCount<256 ; ++iSubCount )
		{
			if( pProtocols->name == NULL )
				break;

			BYTE byProtoNo = pProtocols->code;
			WORD wKey = MAKEWORD(byCateNo, byProtoNo);

			pProtocols++;
		}

		if( !(iSubCount < 256) )
		{
			printf( "Error : IndexOutOfRange Protocol Count\n" );
		}
		else
		{
			pPROTOCOL_BOUNDs[iCount] = iSubCount;
			iSum += iSubCount;
		}

		pPTR++;
	}

	if( !(iCount < 256) )
		return -1;

	pCATEGORY_BOUNDs[0] = iCount;

	// count <0>,<1>ÀÇ ±¸ºÐÀº ÇÊ¿äÇÏÁö¸¸ ¿©±â¼­´Â ¹«½ÃÇϱâ·Î ÇÏÀÚ.
	return iSum;
}

#endif //__CPSHOW_UNUSED_SECT__

//static VOID		_MAKETABLE()
//{
//	typedef pair<WORD, PROTOCOL_STRUCT*>		CPSHOW_PAIR;
//	typedef list<CPSHOW_PAIR>					CPSHOW_DLIST;
//	typedef list<CPSHOW_PAIR>::iterator			CPSHOW_DLIST_IT;
//	typedef vector<CPSHOW_DLIST*>				CPSHOW_CLIST;
//
//	CPSHOW_CLIST cateLIST;
//	cateLIST.reserve( INDEX_SIZE );
//
//	for( int i=0 ; i<INDEX_SIZE ; ++i )
//	{
//		CPSHOW_DLIST* p_dLIST = new CPSHOW_DLIST;
//		cateLIST[i] = p_dLIST;
//	}
//
//	int iCount;
//	int iSum = 0;
//
//	const PROTOCOL_STRUCT_CATEINDEX* pPTR = &idxCG_CATEGORY[0];
//	for( iCount=0 ; iCount<256 ; ++iCount )
//	{
//		if( pPTR->pProtocols == NULL )
//			break;
//
//		BYTE byCateNo = (BYTE)pPTR->dwIndex;
//		const PROTOCOL_STRUCT* pProtocols = pPTR->pProtocols;
//
//		int iSubCount = 0;
//		for( ; iSubCount<256 ; ++iSubCount )
//		{
//			if( pProtocols->name == NULL )
//				break;
//
//			BYTE byProtoNo = pProtocols->code;
//			WORD wKey = MAKEWORD(byCateNo, byProtoNo);
//
//			WORD wUKey = GET_KEY(wKey);// (WORD)(wKey/29) % INDEX_SIZE;
//			CPSHOW_DLIST& dList = *cateLIST[wUKey];
//
//			cateLIST[wUKey]->insert( cateLIST[wUKey]->end(), CPSHOW_PAIR(wKey, (PROTOCOL_STRUCT*)pProtocols));
//
//			pProtocols++;
//		}
//
//		if( !(iSubCount < 256) )
//		{
//			printf( "Error : IndexOutOfRange Protocol Count\n" );
//		}
//		else
//		{
//			iSum += iSubCount;
//		}
//
//		pPTR++;
//	}
//
//	if( !(iCount < 256) )
//	{
//		printf( "Error : IndexOutOfRange Protocol Count\n" );
//		return;
//	}
//
//	//static DWORD ListTableLength = 0;
//	//static SListTable* pListTable = NULL;
//	//static SIndexTable IndexTable[256] = { NULL, };
//	ListTableLength = (DWORD)iSum;
//	pListTable = (SListTable*)malloc( sizeof(SListTable)*ListTableLength );
//
//	// <test code>
//	//BYTE bylists[256] = { 0, };
//	//for( iCount=0 ; iCount<256 ; ++iCount )
//	//{
//	//	CPSHOW_DLIST& rDLIST = *cateLIST[iCount];
//	//	bylists[iCount] = rDLIST.size();
//	//}
//
//	SListTable* pListOffset = pListTable;
//	for( iCount=0 ; iCount<INDEX_SIZE ; ++iCount )
//	{
//		CPSHOW_DLIST& rDLIST = *cateLIST[iCount];
//		//DWORD dwSize = rDLIST.size();
//
//		IndexTable[iCount].pList = pListOffset;
//
//		CPSHOW_DLIST_IT it(rDLIST.begin()), end(rDLIST.end());
//		DWORD dwIdx=0;
//		for( ; it != end ; ++it )
//		{
//			WORD wUKey = it->first;
//			PROTOCOL_STRUCT* pProtocol = it->second;
//			pListOffset->wUKey = wUKey;
//			pListOffset->name = pProtocol->name;
//			++pListOffset;
//			++dwIdx;
//		}
//		IndexTable[iCount].dwCount = dwIdx;
//	}
//
//	for( int i=0 ; i<INDEX_SIZE ; ++i )
//	{
//		delete cateLIST[i];
//	}
//}

#endif //CPSHOWLIB_VERSION