[Tutorial] How to Detour the Kal Mainserver

spatti88 · Aug 19, 2013

first try to make Sword Dance because this skill don't has preskill.

2nd question:

just make NOPS at this error, or use my main.

You must be registered to see links

asas12 · Aug 19, 2013

Ty for new nmain 2 error fixed but I am write behead skill for thief and dont working

spatti88 · Aug 19, 2013

i said already... you have to fix preskill function, or now just make without preskill(sword dance)

asas12 · Aug 20, 2013

you have sirix skill proje ?

spatti88 · Aug 20, 2013

nope noone has...i gave u already full code to make skill

just go get headers and compile it

asas12 · Aug 20, 2013

I have all headers I tested this but no working

Matynator · Aug 23, 2013

spatti88 said:
nope noone has...i gave u already full code to make skill just go get headers and compile it

no headers needed... if so.. make them...

lol

spatti88 · Aug 23, 2013

hmm , that's truth... just compile code

it must work

asas12 · Aug 23, 2013

You must be registered to see links

take this please test it

Akamaru · Aug 23, 2013

New skills like PD doesn't pass PreSkill test. It can be easily fixed, you just have to see how PreSkill works and name variables.
CPlayer:

rocess (case 43)

strik3r2k5 · Aug 23, 2013

D: pre skill(svr side) is just sending the Pre skill packet(client side) haha

Akamaru · Aug 23, 2013

It's in other order imo

Client send 0x2b packet to CPlayer:

rocess and then WriteInSight display correct animation :>

asas12 · Aug 23, 2013

Alex can you write any example for this skill ?

spatti88 · Aug 23, 2013

get ur skills and fix it

it working like all others skills, you have just configure it out .

if ( (*(_DWORD *)(this + 20) & 9) == 8 )
{
ReadPacketSecure(params, paramsend, (unsigned int)"bd", &v191, &v190);
if ( CChar__IsGState(playerpointer, 8192) )
{
CChar__SubGState(playerpointer, 8192);
*(_DWORD *)(playerpointer + 1448) = GetTickCount();
}
if ( (signed int)v191 < 93 )
{
if ( CPlayerSkill__PreSkill((void *)(pPlayer + 624), v191, v190) )
CChar__WriteInSight(playerpointer, 61, (unsigned int)"dbbd", *(_DWORD *)(playerpointer + 28), 5, v191, v190);
}
}
break;
}

strik3r2k5 · Aug 23, 2013

Akamaru said:
It's in other order imo Client send 0x2b packet to CPlayer:rocess and then WriteInSight display correct animation :>

Yea I meant that the server is sending the requested animation back. I'm not at home so I can't post sources sorry...

MadKnight · Aug 24, 2013

I have another usefull list for develop interested People : )

This are the Mainserver enums and structures.

Code:

struct type_info
{
  void *vftable;
  int _m_data;
  char _m_d_name[];
};


struct PMD
{
  int mdisp;
  int pdisp;
  int vdisp;
};


struct RTTIBaseClassDescriptor
{
  void *pTypeDescriptor;
  int numContainedBases;
  PMD pmd;
  int attributes;
};


struct RTTIClassHierarchyDescriptor
{
  int signature;
  int attributes;
  int numBaseClasses;
  void *pBaseClassArray;
};


struct RTTICompleteObjectLocator
{
  int signature;
  int offset;
  int cdOffset;
  void *pTypeDescriptor;
  void *pClassDescriptor;
};


struct RTCI
{
  void *m_lpszClassName;
  int m_nObjectSize;
  int m_wSchema;
  void *m_pfnCreateObject;
  void *m_pfnGetBaseClass;
  int m_pNextClass;
  int m_pClassInit;
};


enum std::basic_string<char,std::char_traits<char>,std::allocator<char> >::__unnamed
{
  _BUF_SIZE = 0x10,
};


enum LOGIN_TYPE
{
  LT_DELETED = 0x1,
  LT_BLOCKED = 0x2,
  LT_NOTPERMITTED = 0x4,
  LT_FREE = 0x8,
  LT_CFIXCOST = 0x10,
  LT_CFIXAMOUNT = 0x20,
  LT_PFIXCOST = 0x40,
  LT_PFIXAMOUNT = 0x80,
  LT_PAYMASK = 0xF0,
  LT_SPECMASK = 0xF8,
};


enum MESSAGE_TYPE
{
  MSG_SHUTDOWN_MIN = 0x0,
  MSG_SHUTDOWN_SEC = 0x1,
  MSG_SHUTDOWN_NOW = 0x2,
  MSG_SHUTDOWN_CANCEL = 0x3,
  MSG_INVALID_NAME = 0x4,
  MSG_SAMEPLAYERONGAME = 0x5,
  MSG_BLOCKEDPLAYER = 0x6,
  MSG_FAILLOADPLAYER = 0x7,
  MSG_NOTEXISTPLAYER = 0x8,
  MSG_MOVEHACK = 0x9,
  MSG_ALREADYPUTON = 0xA,
  MSG_CANTDELPUTONITEM = 0xB,
  MSG_CLASSLIMIT = 0xC,
  MSG_CANTDROPPUTONITEM = 0xD,
  MSG_DODGED = 0xE,
  MSG_USERCOUNT = 0xF,
  MSG_USERALLCOUNT = 0x10,
  MSG_INVENTORYISFULL = 0x11,
  MSG_CURRENCY = 0x12,
  MSG_DESTPLAYERONTRADE = 0x13,
  MSG_NOTENOUGHSLOT = 0x14,
  MSG_INVALID_ITEMLIST = 0x15,
  MSG_TRADEAGREED = 0x16,
  MSG_PRIORITYOFITEM = 0x17,
  MSG_TOOFARFROMME = 0x18,
  MSG_THEREISNOPLAYER = 0x19,
  MSG_NEEDPUPOINT = 0x1A,
  MSG_NORIGHTOFPARTYHEAD = 0x1B,
  MSG_ASKJOINPARTY = 0x1C,
  MSG_JOINEDINPARTY = 0x1D,
  MSG_PARTYISFULL = 0x1E,
  MSG_JOINEDINOTHERPARTY = 0x1F,
  MSG_LEFTPARTY = 0x20,
  MSG_EXILEDFROMPARTY = 0x21,
  MSG_REJECTJOINPARTY = 0x22,
  MSG_BECOMEPARTYHEAD = 0x23,
  MSG_ENDPARTY = 0x24,
  MSG_OFFLINE_OUTOFRANGE = 0x25,
};


enum BASE_BIT
{
  BBIT_DELETE = 0x0,
};


enum S2C_PROTOCOL
{
  S2C_CODE = 0x0,
  S2C_ANS_LOGIN = 0x1,
  S2C_ANS_NEWPLAYER = 0x2,
  S2C_PLAYERINFO = 0x3,
  S2C_ANS_LOAD = 0x4,
  S2C_ANS_START = 0x5,
  S2C_ANS_RESTART = 0x6,
  S2C_ALIVE = 0x7,
  S2C_CLOSE = 0x8,
  S2C_GSTATE = 0x9,
  S2C_MOVEBEFORE = 0xA,
  S2C_MOVEPLAYER_ON = 0xB,
  S2C_MOVEPLAYER_END = 0xC,
  S2C_MOVEMONSTER_ON = 0xD,
  S2C_MOVEMONSTER_END = 0xE,
  S2C_MOVENPC_ON = 0xF,
  S2C_MOVENPC_END = 0x10,
  S2C_MOVEHORSE_ON = 0x11,
  S2C_MOVEHORSE_END = 0x12,
  S2C_CREATEPLAYER = 0x13,
  S2C_CREATEMONSTER = 0x14,
  S2C_CREATENPC = 0x15,
  S2C_CREATEHORSE = 0x16,
  S2C_CREATEITEM = 0x17,
  S2C_REMOVEPLAYER = 0x18,
  S2C_REMOVEMONSTER = 0x19,
  S2C_REMOVENPC = 0x1A,
  S2C_REMOVEHORSE = 0x1B,
  S2C_REMOVEITEM = 0x1C,
  S2C_CHATTING = 0x1D,
  S2C_ACTION = 0x1E,
  S2C_ATTACK = 0x1F,
  S2C_SKILL = 0x20,
  S2C_INFODIE = 0x21,
  S2C_DEFENSE = 0x22,
  S2C_PROPERTY = 0x23,
  S2C_MESSAGE = 0x24,
  S2C_MESSAGEV = 0x25,
  S2C_UPDATEPROPERTY = 0x26,
  S2C_TELEPORT = 0x27,
  S2C_ITEMINFO = 0x28,
  S2C_PUTONITEM = 0x29,
  S2C_PUTOFFITEM = 0x2A,
  S2C_INSERTITEM = 0x2B,
  S2C_TRASHITEM = 0x2C,
  S2C_UPDATEITEMNUM = 0x2D,
  S2C_NOTICE = 0x2E,
  S2C_SKILLINFO = 0x2F,
  S2C_MSTATE = 0x30,
  S2C_UPDATEMPROPERTY = 0x31,
  S2C_EFFECT = 0x32,
  S2C_ANS_ASKNPC = 0x33,
  S2C_ASKTRADE = 0x34,
  S2C_ITEMLIST = 0x35,
  S2C_OPENTRADE = 0x36,
  S2C_CLOSETRADE = 0x37,
  S2C_SHOWOFFITEM = 0x38,
  S2C_ANS_TRADEITEM = 0x39,
  S2C_SKILLUP = 0x3A,
  S2C_ASKPARTY = 0x3B,
  S2C_PARTYMEMPOS = 0x3C,
  S2C_PARTYINFO = 0x3D,
  S2C_UPDATEPARTY = 0x3E,
  S2C_END = 0x3F,
};


enum std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl
{
  _Red = 0x0,
  _Black = 0x1,
};


enum $9E8ADB6017C62D672C6390A518E51DF8
{
  TBIT_START = 0x1,
  TBIT_CANCEL = 0x2,
  TBIT_SETTIMER = 0x3,
  TBIT_END = 0x4,
};


enum $70ABDFF7CDCBE7960FFD27954E4D4104
{
  CANT_END = 0x0,
  NORMAL_END = 0x1,
  ABNORMAL_END = 0x2,
  CANCEL_END = 0x3,
};


enum Symbol
{
  S_NULL = 0x0,
  S_NAME = 0x1,
  S_INDEX = 0x2,
  S_MAP = 0x3,
  S_AREA = 0x4,
  S_MAX = 0x5,
  S_RECT = 0x6,
  S_LEVEL = 0x7,
  S_RACE = 0x8,
  S_STR = 0x9,
  S_HTH = 0xA,
  S_INT = 0xB,
  S_WIS = 0xC,
  S_DEX = 0xD,
  S_HP = 0xE,
  S_MP = 0xF,
  S_HIT = 0x10,
  S_DODGE = 0x11,
  S_ATTACK = 0x12,
  S_MAGIC = 0x13,
  S_DEFENSE = 0x14,
  S_ABSORB = 0x15,
  S_ASPEED = 0x16,
  S_MSPEED = 0x17,
  S_RESIST = 0x18,
  S_RESIST_FIRE = 0x19,
  S_RESIST_ICE = 0x1A,
  S_RESIST_LITNING = 0x1B,
  S_RESIST_CURSE = 0x1C,
  S_RESIST_PALSY = 0x1D,
  S_KIND = 0x1E,
  S_XY = 0x1F,
  S_FILENAME = 0x20,
  S_AI = 0x21,
  S_RANGE = 0x22,
  S_SIGHT = 0x23,
  S_EXP = 0x24,
  S_ITEMGROUP = 0x25,
  S_CLASS = 0x26,
  S_LIMIT = 0x27,
  S_BUY = 0x28,
  S_ENDURANCE = 0x29,
  S_SPECIALTY = 0x2A,
  S_TELEPORT = 0x2B,
  S_IMAGE = 0x2C,
  S_ACTION = 0x2D,
  S_REFRESH = 0x2E,
  S_WEAR = 0x2F,
  S_USE = 0x30,
  S_PLURAL = 0x31,
  S_ITEM = 0x32,
  S_GROUP = 0x33,
  S_MONEY = 0x34,
  S_MOVE = 0x35,
  S_HTML = 0x36,
  S_SHAPE = 0x37,
  S_DIR = 0x38,
  S_DESC = 0x39,
  S_SELL = 0x3A,
  S_PRE = 0x3B,
  S_DELAY = 0x3C,
  S_LASTTIME = 0x3D,
  S_VALUE1 = 0x3E,
  S_VALUE2 = 0x3F,
  S_CASE = 0x40,
  S_IF = 0x41,
  S_THEN = 0x42,
  S_ELSE = 0x43,
  S_REWARD = 0x44,
  S_PARTY = 0x45,
  S_QUEST = 0x46,
  S_CONTRIBUTE = 0x47,
  S_SUPOINT = 0x48,
  S_SAVE = 0x49,
  S_CLEAR = 0x4A,
  S_LINK = 0x4B,
  S_IN = 0x4C,
  S_OUT = 0x4D,
  S_LINKED = 0x4E,
};


enum C2S_PROTOCOL
{
  C2S_CONNECT = 0x0,
  C2S_ANS_CODE = 0x1,
  C2S_LOGIN = 0x2,
  C2S_NEWPLAYER = 0x3,
  C2S_DELPLAYER = 0x4,
  C2S_LOADPLAYER = 0x5,
  C2S_ALIVE = 0x6,
  C2S_RESERVED2 = 0x7,
  C2S_RESERVED3 = 0x8,
  C2S_RESERVED4 = 0x9,
  C2S_RESERVED5 = 0xA,
  C2S_START = 0xB,
  C2S_RESTART = 0xC,
  C2S_MOVE_ON = 0xD,
  C2S_MOVE_END = 0xE,
  C2S_ATTACK = 0xF,
  C2S_SKILL = 0x10,
  C2S_CHATTING = 0x11,
  C2S_TELEPORT = 0x12,
  C2S_ASKNPC = 0x13,
  C2S_ITEMLIST = 0x14,
  C2S_BUYITEM = 0x15,
  C2S_SELLITEM = 0x16,
  C2S_DROPITEM = 0x17,
  C2S_SHOWOFFITEM = 0x18,
  C2S_TRADEITEM = 0x19,
  C2S_TRASHITEM = 0x1A,
  C2S_PUTONITEM = 0x1B,
  C2S_PUTOFFITEM = 0x1C,
  C2S_ACTION = 0x1D,
  C2S_UPDATEPROPERTY = 0x1E,
  C2S_REST = 0x1F,
  C2S_PICKUPITEM = 0x20,
  C2S_USEITEM = 0x21,
  C2S_ASKTRADE = 0x22,
  C2S_ANS_ASKTRADE = 0x23,
  C2S_CANCELTRADE = 0x24,
  C2S_REVIVAL = 0x25,
  C2S_LEARNSKILL = 0x26,
  C2S_SKILLUP = 0x27,
  C2S_PRESKILL = 0x28,
  C2S_ASKPARTY = 0x29,
  C2S_ANS_ASKPARTY = 0x2A,
  C2S_LEAVEPARTY = 0x2B,
  C2S_EXILEPARTY = 0x2C,
  C2S_PUTINSTORAGE = 0x2D,
  C2S_PUTOUTSTORAGE = 0x2E,
  C2S_QUEST = 0x2F,
  C2S_STORAGEINFO = 0x30,
  C2S_END = 0x31,
};


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Redbl;


enum std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed
{
  _Multi = 0x0,
};


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0>::__unnamed;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0>::__unnamed;


enum ATTR
{
  ATTR_PLAYER = 0x1,
  ATTR_MONSTER = 0x2,
  ATTR_NPC = 0x3,
  ATTR_ITEM = 0x4,
};


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0>::__unnamed;


typedef $C76430121188DB029AABDFCFE322BAEC WELL_KNOWN_SID_TYPE;


enum std::_Uninitialized
{
  _Noinit = 0x0,
};


typedef $0FC989869F227A36D749990E523E5F04 POWER_ACTION;


typedef $C9C41CE7F7AB140BE1C872069B92FC11 LATENCY_TIME;


typedef $091388B5486C38E232712F2AD090397D POWER_INFORMATION_LEVEL;


typedef $8C57D1DDA788D6050A7C554DBD1EB1AC ADDRESS_MODE;


typedef $B7D1CDF80B7CC72DADF079F75B7264FC SYM_TYPE;


enum _COMPUTER_NAME_TYPE
{
  PrimaryComputerName = 0x0,
  AlternateComputerNames = 0x1,
  AllComputerNames = 0x2,
  ComputerNameTypeMax = 0x3,
};


typedef $0FA2438F6DACE86812761B9F903D20EE $449F4C83174DB40EB4FD9C7BF2927223;


enum std::codecvt_base::__unnamed
{
  ok = 0x0,
  partial = 0x1,
  error = 0x2,
  noconv = 0x3,
};


enum std::_Iosb<int>::_Dummy_enum
{
  _Dummy_enum_val = 0x1,
};


enum std::_Iosb<int>::_Fmtflags
{
  _Fmtmask = 0xFFFF,
  _Fmtzero = 0x0,
};


enum std::_Iosb<int>::_Iostate
{
  _Statmask = 0x17,
};


enum std::_Iosb<int>::_Openmode
{
  _Openmask = 0xFF,
};


enum std::_Iosb<int>::_Seekdir
{
  _Seekmask = 0x3,
};


enum std::_Iosb<int>::__unnamed
{
  _Openprot = 0x1B6,
};


enum std::ctype_base::__unnamed
{
  alnum = 0x107,
  alpha = 0x103,
  cntrl = 0x20,
  digit = 0x4,
  graph = 0x117,
  lower = 0x2,
  print = 0x1D7,
  punct = 0x10,
  space = 0x48,
  upper = 0x1,
  xdigit = 0x80,
};


enum std::ios_base::event
{
  erase_event = 0x0,
  imbue_event = 0x1,
  copyfmt_event = 0x2,
};


enum S2D_PROTOCOL
{
  S2D_LOADPLAYER = 0x0,
  S2D_SAVEPROPERTY = 0x1,
  S2D_DELETEITEM = 0x2,
  S2D_PUTONITEM = 0x3,
  S2D_PUTOFFITEM = 0x4,
  S2D_INSERTITEM = 0x5,
  S2D_UPDATEITEMPID = 0x6,
  S2D_UPDATEITEMNUM = 0x7,
  S2D_INSERTSKILL = 0x8,
  S2D_SKILLUP = 0x9,
  S2D_PUTINSTORAGE = 0xA,
  S2D_PUTOUTSTORAGE = 0xB,
  S2D_INSERTQUESTFLAG = 0xC,
  S2D_UPDATEQUESTFLAG = 0xD,
  S2D_SYNC = 0xE,
  S2D_CLOSE = 0xF,
  S2D_LOGIN = 0x10,
  S2D_NEWPLAYER = 0x11,
  S2D_DELPLAYER = 0x12,
  S2D_STORAGEINFO = 0x13,
  S2D_END = 0x14,
};


enum S2A_PROTOCOL
{
  S2A_SYNC = 0x0,
  S2A_LOGIN = 0x1,
  S2A_LOGOUT = 0x2,
  S2A_RELOGIN = 0x3,
  S2A_CLOSE = 0x4,
  S2A_USER = 0x5,
  S2A_USERALL = 0x6,
  S2A_CLEARLOGIN = 0x7,
  S2A_SVRINFO = 0x8,
  S2A_END = 0x9,
};


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0>::__unnamed;


enum ANSWER
{
  ANS_ERROR = 0x0,
  ANS_OK = 0x1,
};


enum LOGIN_ANS
{
  LA_ERROR = 0x0,
  LA_OK = 0x1,
  LA_WRONGID = 0x2,
  LA_WRONGPWD = 0x3,
  LA_SAMEUSER = 0x4,
  LA_BLOCKED = 0x5,
  LA_EXPIRED = 0x6,
  LA_AGELIMITED = 0x7,
  LA_NOTPERMITTED = 0x8,
  LA_LOGINLATER = 0x9,
};


enum NEWPLAYER_ANS
{
  NA_ERROR = 0x0,
  NA_OK = 0x1,
  NA_WRONGJOB = 0x2,
  NA_OVERPLAYERNUM = 0x3,
  NA_OCCUPIEDID = 0x4,
  NA_WRONGPROPERTY = 0x5,
};


enum CLOSE_CONNECT
{
  CC_NORMAL = 0x0,
  CC_KICK = 0x1,
  CC_SAMEPLAYER = 0x2,
  CC_SAMEUSER = 0x3,
  CC_HACK = 0x4,
  CC_EXPIRED = 0x5,
};


enum SOCKET_BIT
{
  SBIT_LOGIN = 0x0,
  SBIT_LOADPLAYER = 0x1,
  SBIT_ONGAME = 0x2,
  SBIT_CLOSED = 0x3,
};


enum $FB60F1F6452092806316B8E1CB1AE1CF
{
  INSERT_FAIL = 0x0,
  INSERT_SUCCESS = 0x1,
  INSERT_NOSLOT = 0x2,
};


enum TYTE_LOG
{
  TL_LOGIN = 0x0,
  TL_LOGOUT = 0x1,
  TL_CREATE = 0x2,
  TL_CREATE_CHEAT = 0x3,
  TL_DELETE = 0x4,
  TL_UPDATEPID = 0x5,
  TL_UPDATENUM = 0x6,
  TL_BUY = 0x7,
  TL_SELL = 0x8,
  TL_USE = 0x9,
  TL_TRADE = 0xA,
  TL_DROP = 0xB,
  TL_PICKUP = 0xC,
  TL_PERMIT = 0xD,
  TL_SKILLUP = 0xE,
};


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Redbl;


enum WEAR_STATE
{
  WS_WEAPON = 0x0,
  WS_SHIELD = 0x1,
  WS_HELMET = 0x2,
  WS_UPPERARMOR = 0x3,
  WS_LOWERARMOR = 0x4,
  WS_GAUNTLET = 0x5,
  WS_BOOTS = 0x6,
  WS_RING = 0x7,
  WS_NECKLACE = 0x8,
  WS_TRINKET = 0x9,
};


enum ACTION_TYPE
{
  AT_COMMON = 0x0,
  AT_GENERAL = 0x1,
  AT_MOVE = 0x2,
  AT_REST = 0x3,
  AT_ATTACK = 0x4,
  AT_SKILL = 0x5,
  AT_DEFENSE = 0x6,
  AT_DAMAGE = 0x7,
  AT_KNEE = 0x8,
  AT_DIE = 0x9,
  AT_BEHEADED = 0xA,
};


enum CHAR_KIND
{
  CK_PLAYER = 0x0,
  CK_MONSTER = 0x1,
  CK_NPC = 0x2,
  CK_HORSE = 0x3,
};


enum PROPERTY_TYPE
{
  P_STR = 0x0,
  P_HTH = 0x1,
  P_INT = 0x2,
  P_WIS = 0x3,
  P_DEX = 0x4,
  P_HP = 0x5,
  P_MP = 0x6,
  P_CURHP = 0x7,
  P_CURMP = 0x8,
  P_HIT = 0x9,
  P_DODGE = 0xA,
  P_MINATTACK = 0xB,
  P_MAXATTACK = 0xC,
  P_MINMAGIC = 0xD,
  P_MAXMAGIC = 0xE,
  P_DEFENSE = 0xF,
  P_ABSORB = 0x10,
  P_ASPEED = 0x11,
  P_RESFIRE = 0x12,
  P_RESICE = 0x13,
  P_RESLITNING = 0x14,
  P_RESCURSE = 0x15,
  P_RESPALSY = 0x16,
  P_PUPOINT = 0x17,
  P_SUPOINT = 0x18,
  P_EXP = 0x19,
  P_LEVEL = 0x1A,
  P_MINMAXATTACK = 0x1B,
  P_MINMAXMAGIC = 0x1C,
  P_RESISTALL = 0x1D,
};


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0>::__unnamed;


enum Token
{
  T_END = 0x0,
  T_VARIABLE = 0x1,
  T_STRING = 0x2,
  T_NEWLINE = 0x3,
  T_EQUAL = 0x4,
  T_COMMA = 0x5,
  T_COLON = 0x6,
  T_OPEN = 0x7,
  T_CLOSE = 0x8,
  T_ERROR = 0x9,
};


enum PLAYER_BIT
{
  PBIT_LOAD = 0x1,
  PBIT_CREATE = 0x2,
  PBIT_ONPLAY = 0x3,
  PBIT_END = 0x4,
};


enum CHAT_TYPE
{
  CHAT_COMMON = 0x0,
  CHAT_WHISPER = 0x1,
  CHAT_PARTY = 0x2,
  CHAT_GUILD = 0x3,
};


enum EFFECT_TYPE
{
  E_HP = 0x0,
  E_MP = 0x1,
  E_LEVELUP = 0x2,
};


enum PLAYER_CLASS
{
  PC_KNIGHT = 0x0,
  PC_MAGE = 0x1,
  PC_ARCHER = 0x2,
  PC_WARRIOR = 0x3,
  PC_ASSASSIN = 0x4,
  PC_TALISMAN = 0x5,
  PC_SPIRITKNIGHT = 0x6,
  PC_MONK = 0x7,
};


enum ITEM_CLASS
{
  IC_WEAPON = 0x0,
  IC_DEFENSE = 0x1,
  IC_ORNAMENT = 0x2,
  IC_GENERAL = 0x3,
  IC_QUEST = 0x4,
  IC_MONEY = 0x5,
};


enum RESIST_TYPE
{
  RT_FIRE = 0x0,
  RT_ICE = 0x1,
  RT_LITNING = 0x2,
  RT_CURSE = 0x3,
  RT_PALSY = 0x4,
};


enum AdminType
{
  A_USER = 0x0,
  A_BLOCKED = 0x1,
  A_RESERVED1 = 0x2,
  A_ADMIN = 0x3,
  A_GM = 0x4,
  A_SUPERADMIN = 0x5,
};


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0>::__unnamed;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Redbl;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0>::__unnamed;


enum NPC_KIND
{
  NK_MERCHANT = 0x0,
  NK_INFORMANT = 0x1,
  NK_GUARD = 0x2,
};


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0>::__unnamed;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Redbl;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0>::__unnamed;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Redbl;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Redbl;


enum MOVE_TYPE
{
  MT_ROAM = 0x0,
  MT_CHASE = 0x1,
  MT_RETURN = 0x2,
  MT_FIX = 0x3,
};


enum CLog::__unnamed
{
  INFO = 0x0,
  NORMAL = 0x1,
  ERR = 0x2,
};


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0>::__unnamed;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Redbl;


enum ITEM_SUBCLASS
{
  ISC_SWORD = 0x0,
  ISC_WAND = 0x1,
  ISC_BOW = 0x2,
  ISC_SHIELD = 0x3,
  ISC_HELMET = 0x4,
  ISC_UPPERARMOR = 0x5,
  ISC_LOWERARMOR = 0x6,
  ISC_GAUNTLET = 0x7,
  ISC_BOOTS = 0x8,
  ISC_RING = 0x9,
  ISC_NECKLACE = 0xA,
  ISC_TRINKET = 0xB,
  ISC_REFRESH = 0xC,
  ISC_CHARM = 0xD,
  ISC_GEM = 0xE,
  ISC_COIN = 0xF,
};


enum D2S_PROTOCOL
{
  D2S_LOGIN = 0x0,
  D2S_VERSION = 0x1,
  D2S_ANS_NEWPLAYER = 0x2,
  D2S_ANS_DELPLAYER = 0x3,
  D2S_LOADPLAYER = 0x4,
  RESVD_D2S_LOADSKILL = 0x5,
  RESVD_D2S_LOADITEM = 0x6,
  D2S_END = 0x7,
};


enum A2S_PROTOCOL
{
  A2S_VERSION = 0x0,
  A2S_LOGIN = 0x1,
  A2S_USER = 0x2,
  A2S_USERALL = 0x3,
  A2S_KICKOUT = 0x4,
  A2S_END = 0x5,
};


enum STATE
{
  ST_NORMAL = 0x0,
  ST_PERCENT = 0x1,
  ST_FLAG = 0x2,
  ST_WIDTH = 0x3,
  ST_DOT = 0x4,
  ST_PRECIS = 0x5,
  ST_SIZE = 0x6,
  ST_TYPE = 0x7,
};


enum CHARTYPE
{
  CH_OTHER = 0x0,
  CH_PERCENT = 0x1,
  CH_DOT = 0x2,
  CH_STAR = 0x3,
  CH_ZERO = 0x4,
  CH_DIGIT = 0x5,
  CH_FLAG = 0x6,
  CH_SIZE = 0x7,
  CH_TYPE = 0x8,
};


enum $1DD7A03358E0D01DD359262876E6A0F0
{
  lkNormal = 0x0,
  lkPrealloc = 0x1,
  lkDeleted = 0x2,
};


enum _RTC_ErrorNumber
{
  _RTC_CHKSTK = 0x0,
  _RTC_CVRT_LOSS_INFO = 0x1,
  _RTC_CORRUPT_STACK = 0x2,
  _RTC_UNINIT_LOCAL_USE = 0x3,
  _RTC_ILLEGAL = 0x4,
};


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0>::__unnamed;


typedef std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Redbl std::_Tree<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Redbl;


typedef std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>::__unnamed std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0>::__unnamed;


enum SYS_CODE
{
  SYS_CLOSEBETA = 0x0,
  SYS_NOSENDALIVE = 0x1,
  SYS_PAY = 0x2,
  SYS_NMSOCKET = 0x3,
  SYS_PARTY = 0x4,
  SYS_QUEST = 0x5,
};


struct _stat
{
  unsigned int st_dev;
  unsigned __int16 st_ino;
  unsigned __int16 st_mode;
  __int16 st_nlink;
  __int16 st_uid;
  __int16 st_gid;
  unsigned int st_rdev;
  int st_size;
  int st_atime;
  int st_mtime;
  int st_ctime;
};


struct _iobuf
{
  char *_ptr;
  int _cnt;
  char *_base;
  int _flag;
  int _file;
  int _charbuf;
  int _bufsiz;
  char *_tmpfname;
};


struct InitCodePage
{
  char dummy[1];
};


struct iless
{
  char dummy[1];
};


struct std::_String_base
{
  char dummy[1];
};


struct std::_Allocator_base<char>
{
  char dummy[1];
};


struct std::allocator<char>
{
  std::_Allocator_base<char> baseclass_0;
};


union $F3279860FD305351EEC4769DE28DFDBA
{
  std::_String_base baseclass_0;
  std::allocator<char> _Alval;
};


struct std::_String_val<char,std::allocator<char> >
{
  $F3279860FD305351EEC4769DE28DFDBA ___u0;
};


union std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Bxty
{
  char _Buf[16];
  char *_Ptr;
};


struct std::basic_string<char,std::char_traits<char>,std::allocator<char> >
{
  std::_String_val<char,std::allocator<char> > baseclass_0;
  std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Bxty _Bx;
  unsigned int _Mysize;
  unsigned int _Myres;
};


struct StrCmp
{
  char dummy[1];
};


struct CIOException::CInit
{
  char dummy[1];
};


struct CIOException
{
  char dummy[1];
};


struct _EXCEPTION_RECORD
{
  unsigned int ExceptionCode;
  unsigned int ExceptionFlags;
  _EXCEPTION_RECORD *ExceptionRecord;
  void *ExceptionAddress;
  unsigned int NumberParameters;
  unsigned int ExceptionInformation[15];
};


struct _FLOATING_SAVE_AREA
{
  unsigned int ControlWord;
  unsigned int StatusWord;
  unsigned int TagWord;
  unsigned int ErrorOffset;
  unsigned int ErrorSelector;
  unsigned int DataOffset;
  unsigned int DataSelector;
  char RegisterArea[80];
  unsigned int Cr0NpxState;
};


struct _CONTEXT
{
  unsigned int ContextFlags;
  unsigned int Dr0;
  unsigned int Dr1;
  unsigned int Dr2;
  unsigned int Dr3;
  unsigned int Dr6;
  unsigned int Dr7;
  _FLOATING_SAVE_AREA FloatSave;
  unsigned int SegGs;
  unsigned int SegFs;
  unsigned int SegEs;
  unsigned int SegDs;
  unsigned int Edi;
  unsigned int Esi;
  unsigned int Ebx;
  unsigned int Edx;
  unsigned int Ecx;
  unsigned int Eax;
  unsigned int Ebp;
  unsigned int Eip;
  unsigned int SegCs;
  unsigned int EFlags;
  unsigned int Esp;
  unsigned int SegSs;
  char ExtendedRegisters[512];
};


struct _EXCEPTION_POINTERS
{
  _EXCEPTION_RECORD *ExceptionRecord;
  _CONTEXT *ContextRecord;
};


struct _RTL_CRITICAL_SECTION
{
  _RTL_CRITICAL_SECTION_DEBUG *DebugInfo;
  int LockCount;
  int RecursionCount;
  void *OwningThread;
  void *LockSemaphore;
  unsigned int SpinCount;
};


struct _LIST_ENTRY
{
  _LIST_ENTRY *Flink;
  _LIST_ENTRY *Blink;
};


struct _RTL_CRITICAL_SECTION_DEBUG
{
  unsigned __int16 Type;
  unsigned __int16 CreatorBackTraceIndex;
  _RTL_CRITICAL_SECTION *CriticalSection;
  _LIST_ENTRY ProcessLocksList;
  unsigned int EntryCount;
  unsigned int ContentionCount;
  unsigned int Spare[2];
};


struct CIOObject
{
  CIOObjectVtbl *vfptr;
  int m_nRef;
};


union $A5A483E05FC9B52B872A8DCFA58CFF52
{
  unsigned int Offset;
  void *Pointer;
};


struct _OVERLAPPED
{
  unsigned int Internal;
  unsigned int InternalHigh;
  $A5A483E05FC9B52B872A8DCFA58CFF52 ___u2;
  unsigned int OffsetHigh;
  void *hEvent;
};


struct CIOObjectVtbl
{
  void *(__thiscall *__vecDelDtor)(CIOObject *this, unsigned int);
  void (__thiscall *OnFree)(CIOObject *this);
  void (__thiscall *OnTimer)(CIOObject *this, int);
  void (__thiscall *OnTimerCallback)(CIOObject *this, int);
  void (__thiscall *OnWaitCallback)(CIOObject *this);
  void (__thiscall *OnIOCallback)(CIOObject *this, int, unsigned int, _OVERLAPPED *);
};


struct CBase
{
  CIOObject baseclass_0;
  CBase *m_pNext;
  unsigned int m_bit;
  unsigned int m_dwAttr;
  int m_nId;
};


struct PROPERTY_BASE
{
  int nBase[7];
};


struct PROPERTY_PT
{
  int nPt[7];
  int nHit;
  int nDodge;
  int nMinAttack;
  int nMaxAttack;
  int nMinMagic;
  int nMaxMagic;
  int nDefense;
  int nAbsorb;
  int nASpeed;
  int nResist[5];
};


struct PROPERTY_PER
{
  int nPer[7];
  int nHit;
  int nDodge;
  int nMinAttack;
  int nMaxAttack;
  int nMinMagic;
  int nMaxMagic;
};


struct CTile
{
  CBase *m_pHead;
  unsigned int m_dwAttr;
};


struct CRWLock
{
  int m_nCount;
  int m_nLock;
  void *m_hREvent;
  void *m_hWEvent;
  unsigned int m_dwEIP[2];
};


struct CCellMap
{
  int m_nX;
  int m_nY;
  CTile *m_pTile;
  CRWLock *m_pLock;
};


struct CSMap
{
  int m_nIndex;
  int m_nKind;
  CCellMap *m_pSlot[4096];
};


struct tagPOINT
{
  int x;
  int y;
};


struct CIOCriticalSection
{
  _RTL_CRITICAL_SECTION m_critical_section;
  unsigned int m_dwEIP[2];
};


struct CLink
{
  CLink *m_pNext;
  CLink *m_pPrev;
};


struct CChar
{
  CBase baseclass_0;
  char m_szName[25];
  int m_nLevel;
  PROPERTY_BASE m_prtyBase;
  PROPERTY_PT m_prtyPt;
  PROPERTY_PER m_prtyPer;
  int m_nCurHP;
  int m_nCurMP;
  int m_nGState;
  int m_nMState;
  int m_nRange;
  int m_nMap;
  CSMap *m_pMap;
  tagPOINT m_ptTile;
  tagPOINT m_ptPixel;
  int m_nZ;
  int m_nQIndex;
  int m_nDir;
  CIOCriticalSection m_lock;
  CLink m_link;
};


struct CPlayer
{
  CChar baseclass_0;
  int m_nUID;
  int m_nPID;
  int m_nAdmin;
  int m_nClass;
  unsigned int m_dwSpecialty;
  int m_nContribute;
  __int64 m_nExp;
  int m_nGID;
  int m_nGRole;
  int m_nMoney;
  int m_nPUPoint;
  int m_nSUPoint;
  int m_nKilled;
  int m_nFace;
  int m_nHair;
  unsigned int m_dwWearState;
  unsigned int m_dwEState;
  CPlayerSkill m_skill;
  int m_nParty;
  CIOCriticalSection m_lockItem;
  unsigned __int16 m_wWearItem[7];
  std::map<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> > > m_mapItem;
  std::vector<TRADEITEM,std::allocator<TRADEITEM> > m_vecTrade;
  CItemMoney *m_pMoney;
  CTrade *m_pTrade;
  std::map<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> > > m_mapStorage;
  int m_nCache;
  CIOCriticalSection m_lockQuest;
  std::map<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> > > m_mapMyQuest;
  unsigned int m_dwAutoSave;
  unsigned int m_dwNextAutoRefresh;
  unsigned int m_dwNextAction;
  unsigned int m_dwNextRefresh;
  int m_nTeleMap;
  tagPOINT m_ptTelePixel;
  int m_nTeleZ;
  CSocket *m_pSocket;
};


struct CSkill
{
  CSkillVtbl *vfptr;
  int m_nSkill;
  int m_nLevel;
  int m_nLmtLevel;
  unsigned int m_dwLmtSpecialty;
  int m_nDecMP;
  unsigned int m_dwDelay;
  int m_nLastTime;
  int m_nV1;
  int m_nV2;
  unsigned int m_dwTick;
};


struct CSkillVtbl
{
  CSkill *(__thiscall *Copy)(CSkill *this);
  int (__thiscall *CanExcute)(CSkill *this, CPlayer *, int);
  void (__thiscall *Excute)(CSkill *this, CPlayer *, char *, char *);
  void (__thiscall *ExcutePassive)(CSkill *this, CPlayer *, int, int);
};


struct CPlayerSkill
{
  CPlayer *m_pOwner;
  int m_nClass;
  unsigned int m_dwSkill;
  CSkill *m_pSkill[32];
};


struct std::binary_function<int,int,bool>
{
  char dummy[1];
};


struct std::less<int>
{
  std::binary_function<int,int,bool> baseclass_0;
};


struct std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >
{
  std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CItem *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CItem *> >
{
  std::_Allocator_base<std::pair<int const ,CItem *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CItem *> > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node *_Right;
  std::pair<int const ,CItem *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::binary_function<enum Symbol,enum Symbol,bool>
{
  char dummy[1];
};


struct std::less<enum Symbol>
{
  std::binary_function<enum Symbol,enum Symbol,bool> baseclass_0;
};


struct std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0>
{
  std::less<enum Symbol> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >
{
  std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<enum Symbol const ,CSpec *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<enum Symbol const ,CSpec *> >
{
  std::_Allocator_base<std::pair<enum Symbol const ,CSpec *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> > baseclass_0;
  std::allocator<std::pair<enum Symbol const ,CSpec *> > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node *_Right;
  std::pair<enum Symbol const ,CSpec *> _Myval;
  char _Color;
  char _Isnil;
};


struct CSpec
{
  CSpecVtbl *vfptr;
  int m_nValue1;
};


struct CSpecVtbl
{
  void (__thiscall *ApplySpec)(CSpec *this, CPlayer *);
  void (__thiscall *FreeSpec)(CSpec *this, CPlayer *);
  int (__thiscall *Use)(CSpec *this, CPlayer *);
};


struct std::pair<enum Symbol const ,CSpec *>
{
  Symbol first;
  CSpec *second;
};


struct std::_Tree<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> > >
{
  std::_Tree<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> > baseclass_0;
};


struct CInitItem
{
  CBase baseclass_0;
  char m_szName[31];
  int m_nIndex;
  int m_nClass;
  int m_nSubClass;
  int m_nLevel;
  int m_bWear;
  int m_bUse;
  int m_bPlural;
  int m_nLimit;
  int m_nRange;
  int m_nBuy;
  int m_nSell;
  int m_nEndurance;
  std::map<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> > > m_mapSpec;
};


struct CPrefix
{
  CBase baseclass_0;
  int m_nPrefix;
  int m_nLevel;
  std::map<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> > > m_mapSpec;
};


struct CItem
{
  CBase baseclass_0;
  int m_nPID;
  int m_nIID;
  CInitItem *m_pInit;
  CPrefix *m_pPrefix;
  unsigned int m_dwInfo;
  int m_nNum;
  CSMap *m_pMap;
  tagPOINT m_ptPixel;
  unsigned int m_dwTick;
  int m_bParty;
  CIOCriticalSection m_lock;
};


struct std::pair<int const ,CItem *>
{
  const int first;
  CItem *second;
};


struct std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> > >
{
  std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> > baseclass_0;
};


struct std::_Allocator_base<TRADEITEM>
{
  char dummy[1];
};


struct std::allocator<TRADEITEM>
{
  std::_Allocator_base<TRADEITEM> baseclass_0;
};


struct std::_Vector_val<TRADEITEM,std::allocator<TRADEITEM> >
{
  std::allocator<TRADEITEM> _Alval;
};


struct TRADEITEM
{
  int nIID;
  int nNum;
};


struct std::vector<TRADEITEM,std::allocator<TRADEITEM> >
{
  std::_Vector_val<TRADEITEM,std::allocator<TRADEITEM> > baseclass_0;
  TRADEITEM *_Myfirst;
  TRADEITEM *_Mylast;
  TRADEITEM *_Myend;
};


struct CItemMoney
{
  CItem baseclass_0;
};


struct CTrade
{
  CBase baseclass_0;
  CPlayer *m_pCaller;
  CPlayer *m_pAcc;
};


struct std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >
{
  std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,STORAGEITEM> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,STORAGEITEM> >
{
  std::_Allocator_base<std::pair<int const ,STORAGEITEM> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,STORAGEITEM> > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node *_Right;
  std::pair<int const ,STORAGEITEM> _Myval;
  char _Color;
  char _Isnil;
};


struct STORAGEITEM
{
  unsigned __int16 wIndex;
  int nIID;
  char byPrefix;
  char byInfo;
  int nNum;
  char byMaxEnd;
  char byCurEnd;
  char bySetGem;
  char byXAttack;
  char byXMagic;
  char byXDefense;
  char byXHit;
  char byXDodge;
};


struct std::pair<int const ,STORAGEITEM>
{
  const int first;
  STORAGEITEM second;
};


struct std::_Tree<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> > >
{
  std::_Tree<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> > baseclass_0;
};


struct std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >
{
  std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,MYQUEST> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,MYQUEST> >
{
  std::_Allocator_base<std::pair<int const ,MYQUEST> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,MYQUEST> > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node *_Right;
  std::pair<int const ,MYQUEST> _Myval;
  char _Color;
  char _Isnil;
};


struct MYQUEST
{
  int nFlag;
  int bClear;
};


struct std::pair<int const ,MYQUEST>
{
  const int first;
  MYQUEST second;
};


struct std::_Tree<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> > >
{
  std::_Tree<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> > baseclass_0;
};


struct CIOBuffer
{
  char m_buffer[8000];
  unsigned int m_dwSize;
  int m_nRef;
  CIOBuffer *m_pNext;
};


struct CIOSocket
{
  CIOObject baseclass_0;
  unsigned int m_hSocket;
  CIOCriticalSection m_lock;
  _OVERLAPPED m_overlappedRead;
  _OVERLAPPED m_overlappedWrite;
  CIOBuffer *m_pReadBuf;
  CIOBuffer *m_pFirstBuf;
  CIOBuffer *m_pLastBuf;
  int m_nPendingWrite;
};


struct in_addr::__unnamed::__unnamed
{
  char s_b1;
  char s_b2;
  char s_b3;
  char s_b4;
};


union in_addr::__unnamed
{
  in_addr::__unnamed::__unnamed S_un_b;
  in_addr::__unnamed::__unnamed S_un_w;
  unsigned int S_addr;
};


struct in_addr
{
  in_addr::__unnamed S_un;
};


struct CSocket
{
  CIOSocket baseclass_0;
  unsigned int m_bit;
  CLink m_link;
  CPlayer *m_pPlayer;
  int m_nEncodeCode;
  int m_nDecodeCode;
  int m_nPort;
  in_addr m_addr;
  unsigned int m_dwTick;
  int m_timeLogin;
  int m_nUID;
  int m_nPID;
  int m_nAuthType;
  int m_nExpTime;
  int m_nElapse;
  int m_nCID;
  int m_nNoReplyCnt;
  int m_nId;
};


struct BASEPROPERTY
{
  int prty[5];
  int nHP;
  int nMP;
};


struct CIOSpinLock
{
  int lock;
};


struct CIOBuffer::CSlot
{
  CIOBuffer *m_pBuffer;
  CIOSpinLock m_lock;
};


struct CIOSocket::CInit
{
  char dummy[1];
};


struct CIOSocket::CIOTimer
{
  unsigned int m_dwTime;
  CIOObject *m_pObject;
  int m_nId;
};


struct CIOSocket::CIOTimerInstance
{
  CIOObject baseclass_0;
};


struct lisp::_object
{
  lisp::_objectVtbl *vfptr;
};


struct lisp::var
{
  lisp::_object *m_pObject;
};


struct lisp::_objectVtbl
{
  const char *(__thiscall *GetString)(lisp::_object *this);
  int (__thiscall *GetInteger)(lisp::_object *this);
  unsigned int (__thiscall *GetUnsigned)(lisp::_object *this);
  lisp::var *(__thiscall *car)(lisp::_object *this);
  lisp::var *(__thiscall *cdr)(lisp::_object *this);
  bool (__thiscall *consp)(lisp::_object *this);
  bool (__thiscall *null)(lisp::_object *this);
  bool (__thiscall *stringp)(lisp::_object *this);
  bool (__thiscall *integerp)(lisp::_object *this);
  int (__thiscall *length)(lisp::_object *this);
};


struct lisp::_string
{
  lisp::_object baseclass_0;
  const char *m_pString;
};


struct lisp::_integer
{
  lisp::_object baseclass_0;
  int m_nValue;
};


struct lisp::_cons
{
  lisp::_object baseclass_0;
  lisp::var m_car;
  lisp::var m_cdr;
};


struct lisp::_null
{
  lisp::_object baseclass_0;
};


struct lisp
{
  char dummy[1];
};


struct CBaseList
{
  CBase *m_pBase;
  CBaseList *m_pNext;
};


struct std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >
{
  std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CPlayer *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CPlayer *> >
{
  std::_Allocator_base<std::pair<int const ,CPlayer *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CPlayer *> > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node *_Right;
  std::pair<int const ,CPlayer *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<int const ,CPlayer *>
{
  const int first;
  CPlayer *second;
};


struct std::_Tree<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> > >
{
  std::_Tree<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> > baseclass_0;
};


struct std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0>
{
  StrCmp comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >
{
  std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<char * const,CPlayer *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<char * const,CPlayer *> >
{
  std::_Allocator_base<std::pair<char * const,CPlayer *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> > baseclass_0;
  std::allocator<std::pair<char * const,CPlayer *> > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node *_Right;
  std::pair<char * const,CPlayer *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<char * const,CPlayer *>
{
  char *const first;
  CPlayer *second;
};


struct std::_Tree<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> > >
{
  std::_Tree<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> > baseclass_0;
};


struct CInitSkill
{
  CBase baseclass_0;
  int m_nClass;
  int m_nIndex;
  int m_nLmtLevel;
  unsigned int m_dwLmtSpecialty;
  int m_nDecMP;
  int m_nLastTime;
  unsigned int m_dwDelay;
  int m_nV1;
  int m_nV2;
};


struct CMonsterSkill
{
  char dummy[1];
};


struct CBoost
{
  CSkill baseclass_0;
};


struct CBehead
{
  CSkill baseclass_0;
};


struct CUpWeapon
{
  CSkill baseclass_0;
};


struct CBlow
{
  CSkill baseclass_0;
};


struct CMagic
{
  CSkill baseclass_0;
};


struct CUpMagicRes
{
  CSkill baseclass_0;
};


struct CHealing
{
  CSkill baseclass_0;
};


struct std::iterator<std::random_access_iterator_tag,TRADEITEM,int,TRADEITEM const *,TRADEITEM const &>
{
  char dummy[1];
};


struct std::_Ranit<TRADEITEM,int,TRADEITEM const *,TRADEITEM const &>
{
  std::iterator<std::random_access_iterator_tag,TRADEITEM,int,TRADEITEM const *,TRADEITEM const &> baseclass_0;
};


union $DED07AB25DBF833BDE9B4EF99004D40D
{
  std::_Ranit<TRADEITEM,int,TRADEITEM const *,TRADEITEM const &> baseclass_0;
  TRADEITEM *_Myptr;
};


struct std::vector<TRADEITEM,std::allocator<TRADEITEM> >::const_iterator
{
  $DED07AB25DBF833BDE9B4EF99004D40D ___u0;
};


struct std::vector<TRADEITEM,std::allocator<TRADEITEM> >::iterator
{
  std::vector<TRADEITEM,std::allocator<TRADEITEM> >::const_iterator baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CItem *>,int,std::pair<int const ,CItem *> const *,std::pair<int const ,CItem *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CItem *>,int,std::pair<int const ,CItem *> const *,std::pair<int const ,CItem *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CItem *>,int,std::pair<int const ,CItem *> const *,std::pair<int const ,CItem *> const &> baseclass_0;
};


union $5F69D3757EB9A5BBF343B69A01094F76
{
  std::_Bidit<std::pair<int const ,CItem *>,int,std::pair<int const ,CItem *> const *,std::pair<int const ,CItem *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::const_iterator
{
  $5F69D3757EB9A5BBF343B69A01094F76 ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::const_iterator baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CPlayer *>,int,std::pair<int const ,CPlayer *> const *,std::pair<int const ,CPlayer *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CPlayer *>,int,std::pair<int const ,CPlayer *> const *,std::pair<int const ,CPlayer *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CPlayer *>,int,std::pair<int const ,CPlayer *> const *,std::pair<int const ,CPlayer *> const &> baseclass_0;
};


union $04746D9D875EE92B43EC44EAE1B7B476
{
  std::_Bidit<std::pair<int const ,CPlayer *>,int,std::pair<int const ,CPlayer *> const *,std::pair<int const ,CPlayer *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::const_iterator
{
  $04746D9D875EE92B43EC44EAE1B7B476 ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::const_iterator baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<char * const,CPlayer *>,int,std::pair<char * const,CPlayer *> const *,std::pair<char * const,CPlayer *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<char * const,CPlayer *>,int,std::pair<char * const,CPlayer *> const *,std::pair<char * const,CPlayer *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<char * const,CPlayer *>,int,std::pair<char * const,CPlayer *> const *,std::pair<char * const,CPlayer *> const &> baseclass_0;
};


union $FE55AC736EBC54432A3B76B6D752C0CA
{
  std::_Bidit<std::pair<char * const,CPlayer *>,int,std::pair<char * const,CPlayer *> const *,std::pair<char * const,CPlayer *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::const_iterator
{
  $FE55AC736EBC54432A3B76B6D752C0CA ___u0;
};


struct std::_Tree<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::const_iterator baseclass_0;
};


struct std::allocator<std::pair<int const ,CPlayer *> >::rebind<std::pair<int const ,CPlayer *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CPlayer *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CPlayer *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CPlayer *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CPlayer *> >::rebind<char>
{
  char dummy[1];
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::iterator first;
  bool second;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::iterator,std::_Tree<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::iterator>
{
  std::_Tree<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::iterator first;
  std::_Tree<std::_Tmap_traits<int,CPlayer *,std::less<int>,std::allocator<std::pair<int const ,CPlayer *> >,0> >::iterator second;
};


struct std::_Allocator_base<int>
{
  char dummy[1];
};


struct std::allocator<int>
{
  std::_Allocator_base<int> baseclass_0;
};


struct std::allocator<std::pair<char * const,CPlayer *> >::rebind<std::pair<char * const,CPlayer *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<char * const,CPlayer *> >::rebind<std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<char * const,CPlayer *> >::rebind<std::_Tree_nod<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<char * const,CPlayer *> >::rebind<char *>
{
  char dummy[1];
};


struct std::allocator<std::pair<char * const,CPlayer *> >::rebind<char>
{
  char dummy[1];
};


struct std::pair<std::_Tree<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::iterator first;
  bool second;
};


struct std::pair<std::_Tree<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::iterator,std::_Tree<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::iterator>
{
  std::_Tree<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::iterator first;
  std::_Tree<std::_Tmap_traits<char *,CPlayer *,StrCmp,std::allocator<std::pair<char * const,CPlayer *> >,0> >::iterator second;
};


struct std::_Allocator_base<char *>
{
  char dummy[1];
};


struct std::allocator<char *>
{
  std::_Allocator_base<char *> baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::iterator first;
  bool second;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::iterator,std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::iterator>
{
  std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::iterator first;
  std::_Tree<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::iterator second;
};


struct std::allocator<std::pair<int const ,CItem *> >::rebind<std::pair<int const ,CItem *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CItem *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CItem *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CItem *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CItem *> >::rebind<char>
{
  char dummy[1];
};


struct std::input_iterator_tag
{
  char dummy[1];
};


struct std::forward_iterator_tag
{
  std::input_iterator_tag baseclass_0;
};


struct std::bidirectional_iterator_tag
{
  std::forward_iterator_tag baseclass_0;
};


struct std::allocator<TRADEITEM>::rebind<TRADEITEM>
{
  char dummy[1];
};


struct std::allocator<char>::rebind<char>
{
  char dummy[1];
};


struct std::iterator<std::random_access_iterator_tag,char,int,char const *,char const &>
{
  char dummy[1];
};


struct std::_Ranit<char,int,char const *,char const &>
{
  std::iterator<std::random_access_iterator_tag,char,int,char const *,char const &> baseclass_0;
};


union $DF1F3481EA3EF9FCB2C7CF75FF141648
{
  std::_Ranit<char,int,char const *,char const &> baseclass_0;
  const char *_Myptr;
};


struct std::basic_string<char,std::char_traits<char>,std::allocator<char> >::const_iterator
{
  $DF1F3481EA3EF9FCB2C7CF75FF141648 ___u0;
};


struct std::basic_string<char,std::char_traits<char>,std::allocator<char> >::iterator
{
  std::basic_string<char,std::char_traits<char>,std::allocator<char> >::const_iterator baseclass_0;
};


struct std::char_traits<char>
{
  char dummy[1];
};


struct std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >
{
  std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CInitItem *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CInitItem *> >
{
  std::_Allocator_base<std::pair<int const ,CInitItem *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CInitItem *> > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node *_Right;
  std::pair<int const ,CInitItem *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<int const ,CInitItem *>
{
  const int first;
  CInitItem *second;
};


struct std::_Tree<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> > >
{
  std::_Tree<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> > baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CInitItem *>,int,std::pair<int const ,CInitItem *> const *,std::pair<int const ,CInitItem *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CInitItem *>,int,std::pair<int const ,CInitItem *> const *,std::pair<int const ,CInitItem *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CInitItem *>,int,std::pair<int const ,CInitItem *> const *,std::pair<int const ,CInitItem *> const &> baseclass_0;
};


union $A06747605A0D9F7FF950F34FEC317EA2
{
  std::_Bidit<std::pair<int const ,CInitItem *>,int,std::pair<int const ,CInitItem *> const *,std::pair<int const ,CInitItem *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::const_iterator
{
  $A06747605A0D9F7FF950F34FEC317EA2 ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::const_iterator baseclass_0;
};


struct std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >
{
  std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CPrefix *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CPrefix *> >
{
  std::_Allocator_base<std::pair<int const ,CPrefix *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CPrefix *> > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node *_Right;
  std::pair<int const ,CPrefix *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<int const ,CPrefix *>
{
  const int first;
  CPrefix *second;
};


struct std::_Tree<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> > >
{
  std::_Tree<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> > baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CPrefix *>,int,std::pair<int const ,CPrefix *> const *,std::pair<int const ,CPrefix *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CPrefix *>,int,std::pair<int const ,CPrefix *> const *,std::pair<int const ,CPrefix *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CPrefix *>,int,std::pair<int const ,CPrefix *> const *,std::pair<int const ,CPrefix *> const &> baseclass_0;
};


union $141CB724B0F7208E67F9ECB2FC92FEBC
{
  std::_Bidit<std::pair<int const ,CPrefix *>,int,std::pair<int const ,CPrefix *> const *,std::pair<int const ,CPrefix *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::const_iterator
{
  $141CB724B0F7208E67F9ECB2FC92FEBC ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::const_iterator baseclass_0;
};


struct std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >
{
  std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CItemGroup *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CItemGroup *> >
{
  std::_Allocator_base<std::pair<int const ,CItemGroup *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CItemGroup *> > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node *_Right;
  std::pair<int const ,CItemGroup *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::_Allocator_base<ITEMGROUP>
{
  char dummy[1];
};


struct std::allocator<ITEMGROUP>
{
  std::_Allocator_base<ITEMGROUP> baseclass_0;
};


struct std::_Vector_val<ITEMGROUP,std::allocator<ITEMGROUP> >
{
  std::allocator<ITEMGROUP> _Alval;
};


struct std::_Allocator_base<ITEMDROPINFO>
{
  char dummy[1];
};


struct std::allocator<ITEMDROPINFO>
{
  std::_Allocator_base<ITEMDROPINFO> baseclass_0;
};


struct std::_Vector_val<ITEMDROPINFO,std::allocator<ITEMDROPINFO> >
{
  std::allocator<ITEMDROPINFO> _Alval;
};


struct ITEMDROPINFO
{
  int nPer;
  int nItemID;
  int nPrefix;
  int nNum;
};


struct std::vector<ITEMDROPINFO,std::allocator<ITEMDROPINFO> >
{
  std::_Vector_val<ITEMDROPINFO,std::allocator<ITEMDROPINFO> > baseclass_0;
  ITEMDROPINFO *_Myfirst;
  ITEMDROPINFO *_Mylast;
  ITEMDROPINFO *_Myend;
};


struct CGroup
{
  CBase baseclass_0;
  int m_nID;
  std::vector<ITEMDROPINFO,std::allocator<ITEMDROPINFO> > m_vecItemInfo;
};


struct ITEMGROUP
{
  int nPer;
  CGroup *pGroup;
};


struct std::vector<ITEMGROUP,std::allocator<ITEMGROUP> >
{
  std::_Vector_val<ITEMGROUP,std::allocator<ITEMGROUP> > baseclass_0;
  ITEMGROUP *_Myfirst;
  ITEMGROUP *_Mylast;
  ITEMGROUP *_Myend;
};


struct CItemGroup
{
  CBase baseclass_0;
  int m_nIndex;
  std::vector<ITEMGROUP,std::allocator<ITEMGROUP> > m_vecGroup;
};


struct std::pair<int const ,CItemGroup *>
{
  const int first;
  CItemGroup *second;
};


struct std::_Tree<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> > >
{
  std::_Tree<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> > baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CItemGroup *>,int,std::pair<int const ,CItemGroup *> const *,std::pair<int const ,CItemGroup *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CItemGroup *>,int,std::pair<int const ,CItemGroup *> const *,std::pair<int const ,CItemGroup *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CItemGroup *>,int,std::pair<int const ,CItemGroup *> const *,std::pair<int const ,CItemGroup *> const &> baseclass_0;
};


union $CF3B62B65DF4415B1BEB4DA998C6CDD8
{
  std::_Bidit<std::pair<int const ,CItemGroup *>,int,std::pair<int const ,CItemGroup *> const *,std::pair<int const ,CItemGroup *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::const_iterator
{
  $CF3B62B65DF4415B1BEB4DA998C6CDD8 ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::const_iterator baseclass_0;
};


struct std::allocator<std::pair<int const ,CInitItem *> >::rebind<std::pair<int const ,CInitItem *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CInitItem *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CInitItem *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CInitItem *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CInitItem *> >::rebind<char>
{
  char dummy[1];
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CInitItem *,std::less<int>,std::allocator<std::pair<int const ,CInitItem *> >,0> >::iterator first;
  bool second;
};


struct std::allocator<std::pair<int const ,CPrefix *> >::rebind<std::pair<int const ,CPrefix *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CPrefix *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CPrefix *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CPrefix *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CPrefix *> >::rebind<char>
{
  char dummy[1];
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CPrefix *,std::less<int>,std::allocator<std::pair<int const ,CPrefix *> >,0> >::iterator first;
  bool second;
};


struct std::allocator<std::pair<int const ,CItemGroup *> >::rebind<std::pair<int const ,CItemGroup *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CItemGroup *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CItemGroup *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CItemGroup *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CItemGroup *> >::rebind<char>
{
  char dummy[1];
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CItemGroup *,std::less<int>,std::allocator<std::pair<int const ,CItemGroup *> >,0> >::iterator first;
  bool second;
};


struct std::allocator<std::pair<enum Symbol const ,CSpec *> >::rebind<std::pair<enum Symbol const ,CSpec *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<enum Symbol const ,CSpec *> >::rebind<std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<enum Symbol const ,CSpec *> >::rebind<std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<enum Symbol const ,CSpec *> >::rebind<enum Symbol>
{
  char dummy[1];
};


struct std::allocator<std::pair<enum Symbol const ,CSpec *> >::rebind<char>
{
  char dummy[1];
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<enum Symbol const ,CSpec *>,int,std::pair<enum Symbol const ,CSpec *> const *,std::pair<enum Symbol const ,CSpec *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<enum Symbol const ,CSpec *>,int,std::pair<enum Symbol const ,CSpec *> const *,std::pair<enum Symbol const ,CSpec *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<enum Symbol const ,CSpec *>,int,std::pair<enum Symbol const ,CSpec *> const *,std::pair<enum Symbol const ,CSpec *> const &> baseclass_0;
};


union $1D71011BE8184D019B056A9DAAEDE861
{
  std::_Bidit<std::pair<enum Symbol const ,CSpec *>,int,std::pair<enum Symbol const ,CSpec *> const *,std::pair<enum Symbol const ,CSpec *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::const_iterator
{
  $1D71011BE8184D019B056A9DAAEDE861 ___u0;
};


struct std::_Tree<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::const_iterator baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<enum Symbol,CSpec *,std::less<enum Symbol>,std::allocator<std::pair<enum Symbol const ,CSpec *> >,0> >::iterator first;
  bool second;
};


struct std::_Allocator_base<enum Symbol>
{
  char dummy[1];
};


struct std::allocator<enum Symbol>
{
  std::_Allocator_base<enum Symbol> baseclass_0;
};


struct CItemQuest
{
  CItem baseclass_0;
};


struct HWND__
{
  int unused;
};


struct CScreen
{
  char *m_pBuffer;
  int m_nWidth;
  int m_nHeight;
  int m_nLine;
  int m_nPitch;
  CIOCriticalSection m_lock;
};


struct CSpecStr
{
  CSpec baseclass_0;
};


struct CSpecHth
{
  CSpec baseclass_0;
};


struct CSpecInt
{
  CSpec baseclass_0;
};


struct CSpecWis
{
  CSpec baseclass_0;
};


struct CSpecDex
{
  CSpec baseclass_0;
};


struct CSpecAttack
{
  CSpec baseclass_0;
  int m_nValue2;
};


struct CSpecMagic
{
  CSpec baseclass_0;
  int m_nValue2;
};


struct CSpecHP
{
  CSpec baseclass_0;
};


struct CSpecMP
{
  CSpec baseclass_0;
};


struct CSpecDefense
{
  CSpec baseclass_0;
};


struct CSpecHit
{
  CSpec baseclass_0;
};


struct CSpecDodge
{
  CSpec baseclass_0;
};


struct CSpecAbsorb
{
  CSpec baseclass_0;
};


struct CSpecResistFire
{
  CSpec baseclass_0;
};


struct CSpecResistIce
{
  CSpec baseclass_0;
};


struct CSpecResistLitning
{
  CSpec baseclass_0;
};


struct CSpecResistCurse
{
  CSpec baseclass_0;
};


struct CSpecResistPalsy
{
  CSpec baseclass_0;
};


struct CSpecTeleport
{
  CSpec baseclass_0;
};


struct CSpecRefresh
{
  CSpec baseclass_0;
  int m_nValue2;
};


struct CTables
{
  char dummy[1];
};


struct HPMP_REVISE_FORLEVELUP
{
  int nValue;
  int nExtra;
};


struct VILLAGELOCATION
{
  tagPOINT ptPLoc;
  int nZ;
};


struct std::exception
{
  std::exceptionVtbl *vfptr;
  const char *_Ptr;
};


struct std::exceptionVtbl
{
  void *(__thiscall *__vecDelDtor)(std::exception *this, unsigned int);
  const char *(__thiscall *what)(std::exception *this);
  void (__thiscall *_Doraise)(std::exception *this);
};


struct tagEMR
{
  unsigned int iType;
  unsigned int nSize;
};


struct _RECTL
{
  int left;
  int top;
  int right;
  int bottom;
};


struct _POINTL
{
  int x;
  int y;
};


struct tagEMRPOLYLINE
{
  tagEMR emr;
  _RECTL rclBounds;
  unsigned int cptl;
  _POINTL aptl[1];
};


struct tagXFORM
{
  float eM11;
  float eM12;
  float eM21;
  float eM22;
  float eDx;
  float eDy;
};


struct tagEMRTRANSPARENTBLT
{
  tagEMR emr;
  _RECTL rclBounds;
  int xDest;
  int yDest;
  int cxDest;
  int cyDest;
  unsigned int dwRop;
  int xSrc;
  int ySrc;
  tagXFORM xformSrc;
  unsigned int crBkColorSrc;
  unsigned int iUsageSrc;
  unsigned int offBmiSrc;
  unsigned int cbBmiSrc;
  unsigned int offBitsSrc;
  unsigned int cbBitsSrc;
  int cxSrc;
  int cySrc;
};


struct _TAPE_SET_DRIVE_PARAMETERS
{
  char ECC;
  char Compression;
  char DataPadding;
  char ReportSetmarks;
  unsigned int EOTWarningZoneSize;
};


struct tagCBTACTIVATESTRUCT
{
  int fMouse;
  HWND__ *hWndActive;
};


struct _NETRESOURCEW
{
  unsigned int dwScope;
  unsigned int dwType;
  unsigned int dwDisplayType;
  unsigned int dwUsage;
  unsigned __int16 *lpLocalName;
  unsigned __int16 *lpRemoteName;
  unsigned __int16 *lpComment;
  unsigned __int16 *lpProvider;
};


struct _GUID
{
  unsigned int Data1;
  unsigned __int16 Data2;
  unsigned __int16 Data3;
  char Data4[8];
};


struct _WSAVersion
{
  unsigned int dwVersion;
  _WSAEcomparator ecHow;
};


struct _AFPROTOCOLS
{
  int iAddressFamily;
  int iProtocol;
};


struct sockaddr
{
  unsigned __int16 sa_family;
  char sa_data[14];
};


struct _SOCKET_ADDRESS
{
  sockaddr *lpSockaddr;
  int iSockaddrLength;
};


struct _CSADDR_INFO
{
  _SOCKET_ADDRESS LocalAddr;
  _SOCKET_ADDRESS RemoteAddr;
  int iSocketType;
  int iProtocol;
};


struct _BLOB
{
  unsigned int cbSize;
  char *pBlobData;
};


struct _WSAQuerySetA
{
  unsigned int dwSize;
  char *lpszServiceInstanceName;
  _GUID *lpServiceClassId;
  _WSAVersion *lpVersion;
  char *lpszComment;
  unsigned int dwNameSpace;
  _GUID *lpNSProviderId;
  char *lpszContext;
  unsigned int dwNumberOfProtocols;
  _AFPROTOCOLS *lpafpProtocols;
  char *lpszQueryString;
  unsigned int dwNumberOfCsAddrs;
  _CSADDR_INFO *lpcsaBuffer;
  unsigned int dwOutputFlags;
  _BLOB *lpBlob;
};


struct _CRYPTOAPI_BLOB
{
  unsigned int cbData;
  char *pbData;
};


struct _CRYPT_ALGORITHM_IDENTIFIER
{
  char *pszObjId;
  _CRYPTOAPI_BLOB Parameters;
};


struct _FILETIME
{
  unsigned int dwLowDateTime;
  unsigned int dwHighDateTime;
};


struct _CRYPT_BIT_BLOB
{
  unsigned int cbData;
  char *pbData;
  unsigned int cUnusedBits;
};


struct _CERT_PUBLIC_KEY_INFO
{
  _CRYPT_ALGORITHM_IDENTIFIER Algorithm;
  _CRYPT_BIT_BLOB PublicKey;
};


struct _CERT_EXTENSION
{
  char *pszObjId;
  int fCritical;
  _CRYPTOAPI_BLOB Value;
};


struct _CERT_INFO
{
  unsigned int dwVersion;
  _CRYPTOAPI_BLOB SerialNumber;
  _CRYPT_ALGORITHM_IDENTIFIER SignatureAlgorithm;
  _CRYPTOAPI_BLOB Issuer;
  _FILETIME NotBefore;
  _FILETIME NotAfter;
  _CRYPTOAPI_BLOB Subject;
  _CERT_PUBLIC_KEY_INFO SubjectPublicKeyInfo;
  _CRYPT_BIT_BLOB IssuerUniqueId;
  _CRYPT_BIT_BLOB SubjectUniqueId;
  unsigned int cExtension;
  _CERT_EXTENSION *rgExtension;
};


struct _CMSG_ENVELOPED_ENCODE_INFO
{
  unsigned int cbSize;
  unsigned int hCryptProv;
  _CRYPT_ALGORITHM_IDENTIFIER ContentEncryptionAlgorithm;
  void *pvEncryptionAuxInfo;
  unsigned int cRecipients;
  _CERT_INFO **rgpRecipients;
};


struct _CRYPT_TRUST_REG_ENTRY
{
  unsigned int cbStruct;
  unsigned __int16 *pwszDLLName;
  unsigned __int16 *pwszFunctionName;
};


struct _CRYPT_REGISTER_ACTIONID
{
  unsigned int cbStruct;
  _CRYPT_TRUST_REG_ENTRY sInitProvider;
  _CRYPT_TRUST_REG_ENTRY sObjectProvider;
  _CRYPT_TRUST_REG_ENTRY sSignatureProvider;
  _CRYPT_TRUST_REG_ENTRY sCertificateProvider;
  _CRYPT_TRUST_REG_ENTRY sCertificatePolicyProvider;
  _CRYPT_TRUST_REG_ENTRY sFinalPolicyProvider;
  _CRYPT_TRUST_REG_ENTRY sTestPolicyProvider;
  _CRYPT_TRUST_REG_ENTRY sCleanupProvider;
};


struct _QUERY_SERVICE_CONFIGA
{
  unsigned int dwServiceType;
  unsigned int dwStartType;
  unsigned int dwErrorControl;
  char *lpBinaryPathName;
  char *lpLoadOrderGroup;
  unsigned int dwTagId;
  char *lpDependencies;
  char *lpServiceStartName;
  char *lpDisplayName;
};


struct _TOKEN_PRIMARY_GROUP
{
  void *PrimaryGroup;
};


struct _PROCESS_HEAP_ENTRY::__unnamed::__unnamed
{
  void *hMem;
  unsigned int dwReserved[3];
};


union $428534D58A8C8B3C9510B3E5BA8712AD
{
  _PROCESS_HEAP_ENTRY::__unnamed::__unnamed Block;
  _PROCESS_HEAP_ENTRY::__unnamed::__unnamed Region;
};


struct _PROCESS_HEAP_ENTRY
{
  void *lpData;
  unsigned int cbData;
  char cbOverhead;
  char iRegionIndex;
  unsigned __int16 wFlags;
  $428534D58A8C8B3C9510B3E5BA8712AD ___u5;
};


struct tagEMREOF
{
  tagEMR emr;
  unsigned int nPalEntries;
  unsigned int offPalEntries;
  unsigned int nSizeLast;
};


struct _CERT_ISSUER_SERIAL_NUMBER
{
  _CRYPTOAPI_BLOB Issuer;
  _CRYPTOAPI_BLOB SerialNumber;
};


union $8C4876AEC256B2DCCCA0444EB386B77A
{
  _CERT_ISSUER_SERIAL_NUMBER IssuerSerialNumber;
  _CRYPTOAPI_BLOB KeyId;
  _CRYPTOAPI_BLOB HashId;
};


struct _CERT_ID
{
  unsigned int dwIdChoice;
  $8C4876AEC256B2DCCCA0444EB386B77A ___u1;
};


struct _CRYPT_ATTRIBUTE_TYPE_VALUE
{
  char *pszObjId;
  _CRYPTOAPI_BLOB Value;
};


struct _CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO
{
  unsigned int cbSize;
  _CRYPT_BIT_BLOB RecipientPublicKey;
  _CERT_ID RecipientId;
  _FILETIME Date;
  _CRYPT_ATTRIBUTE_TYPE_VALUE *pOtherAttr;
};


union $1C66F5EF2D38DF70A1D65C151B2BC44B
{
  _CRYPT_ALGORITHM_IDENTIFIER *pEphemeralAlgorithm;
  _CERT_ID *pSenderId;
};


struct _CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO
{
  unsigned int cbSize;
  _CRYPT_ALGORITHM_IDENTIFIER KeyEncryptionAlgorithm;
  void *pvKeyEncryptionAuxInfo;
  _CRYPT_ALGORITHM_IDENTIFIER KeyWrapAlgorithm;
  void *pvKeyWrapAuxInfo;
  unsigned int hCryptProv;
  unsigned int dwKeySpec;
  unsigned int dwKeyChoice;
  $1C66F5EF2D38DF70A1D65C151B2BC44B ___u8;
  _CRYPTOAPI_BLOB UserKeyingMaterial;
  unsigned int cRecipientEncryptedKeys;
  _CMSG_RECIPIENT_ENCRYPTED_KEY_ENCODE_INFO **rgpRecipientEncryptedKeys;
};


struct _CMSG_RECIPIENT_ENCRYPTED_KEY_INFO
{
  _CERT_ID RecipientId;
  _CRYPTOAPI_BLOB EncryptedKey;
  _FILETIME Date;
  _CRYPT_ATTRIBUTE_TYPE_VALUE *pOtherAttr;
};


struct _SYMBOL_INFO
{
  unsigned int SizeOfStruct;
  unsigned int TypeIndex;
  unsigned __int64 Reserved[2];
  unsigned int info;
  unsigned int Size;
  unsigned __int64 ModBase;
  unsigned int Flags;
  unsigned __int64 Value;
  unsigned __int64 Address;
  unsigned int Register;
  unsigned int Scope;
  unsigned int Tag;
  unsigned int NameLen;
  unsigned int MaxNameLen;
  char Name[1];
};


struct _SYMBOL_INFO_PACKAGE
{
  _SYMBOL_INFO si;
  char name[2001];
};


struct _SID_AND_ATTRIBUTES
{
  void *Sid;
  unsigned int Attributes;
};


struct _MEMORY_BASIC_INFORMATION64
{
  unsigned __int64 BaseAddress;
  unsigned __int64 AllocationBase;
  unsigned int AllocationProtect;
  unsigned int __alignment1;
  unsigned __int64 RegionSize;
  unsigned int State;
  unsigned int Protect;
  unsigned int Type;
  unsigned int __alignment2;
};


struct _PROCESSOR_POWER_POLICY_INFO
{
  unsigned int TimeCheck;
  unsigned int DemoteLimit;
  unsigned int PromoteLimit;
  char DemotePercent;
  char PromotePercent;
  char Spare[2];
  int _bf16;
};


struct _PROCESSOR_POWER_POLICY
{
  unsigned int Revision;
  char DynamicThrottle;
  char Spare[3];
  int _bf8;
  unsigned int PolicyCount;
  _PROCESSOR_POWER_POLICY_INFO Policy[3];
};


struct tagTOGGLEKEYS
{
  unsigned int cbSize;
  unsigned int dwFlags;
};


struct _tagADDRESS64
{
  unsigned __int64 Offset;
  unsigned __int16 Segment;
  ADDRESS_MODE Mode;
};


struct tagBITMAPFILEHEADER
{
  unsigned __int16 bfType;
  unsigned int bfSize;
  unsigned __int16 bfReserved1;
  unsigned __int16 bfReserved2;
  unsigned int bfOffBits;
};


struct _MINIDUMP_STRING
{
  unsigned int Length;
  unsigned __int16 Buffer[];
};


struct tagEMRARC
{
  tagEMR emr;
  _RECTL rclBox;
  _POINTL ptlStart;
  _POINTL ptlEnd;
};


struct tagNMHDR
{
  HWND__ *hwndFrom;
  unsigned int idFrom;
  unsigned int code;
};


struct tagLOGFONTW
{
  int lfHeight;
  int lfWidth;
  int lfEscapement;
  int lfOrientation;
  int lfWeight;
  char lfItalic;
  char lfUnderline;
  char lfStrikeOut;
  char lfCharSet;
  char lfOutPrecision;
  char lfClipPrecision;
  char lfQuality;
  char lfPitchAndFamily;
  unsigned __int16 lfFaceName[32];
};


struct tagICONMETRICSW
{
  unsigned int cbSize;
  int iHorzSpacing;
  int iVertSpacing;
  int iTitleWrap;
  tagLOGFONTW lfFont;
};


struct _currencyfmtA
{
  unsigned int NumDigits;
  unsigned int LeadingZero;
  unsigned int Grouping;
  char *lpDecimalSep;
  char *lpThousandSep;
  unsigned int NegativeOrder;
  unsigned int PositiveOrder;
  char *lpCurrencySymbol;
};


struct val_context
{
  int valuelen;
  void *value_context;
  void *val_buff_ptr;
};


struct _CERT_CONTEXT
{
  unsigned int dwCertEncodingType;
  char *pbCertEncoded;
  unsigned int cbCertEncoded;
  _CERT_INFO *pCertInfo;
  void *hCertStore;
};


struct _CERT_TRUST_STATUS
{
  unsigned int dwErrorStatus;
  unsigned int dwInfoStatus;
};


struct _CRL_ENTRY
{
  _CRYPTOAPI_BLOB SerialNumber;
  _FILETIME RevocationDate;
  unsigned int cExtension;
  _CERT_EXTENSION *rgExtension;
};


struct _CRL_INFO
{
  unsigned int dwVersion;
  _CRYPT_ALGORITHM_IDENTIFIER SignatureAlgorithm;
  _CRYPTOAPI_BLOB Issuer;
  _FILETIME ThisUpdate;
  _FILETIME NextUpdate;
  unsigned int cCRLEntry;
  _CRL_ENTRY *rgCRLEntry;
  unsigned int cExtension;
  _CERT_EXTENSION *rgExtension;
};


const struct _CRL_CONTEXT
{
  unsigned int dwCertEncodingType;
  char *pbCrlEncoded;
  unsigned int cbCrlEncoded;
  _CRL_INFO *pCrlInfo;
  void *hCertStore;
};


struct _CERT_REVOCATION_CRL_INFO
{
  unsigned int cbSize;
  _CRL_CONTEXT *pBaseCrlContext;
  _CRL_CONTEXT *pDeltaCrlContext;
  _CRL_ENTRY *pCrlEntry;
  int fDeltaCrlEntry;
};


struct _CERT_REVOCATION_INFO
{
  unsigned int cbSize;
  unsigned int dwRevocationResult;
  const char *pszRevocationOid;
  void *pvOidSpecificInfo;
  int fHasFreshnessTime;
  unsigned int dwFreshnessTime;
  _CERT_REVOCATION_CRL_INFO *pCrlInfo;
};


struct _CTL_USAGE
{
  unsigned int cUsageIdentifier;
  char **rgpszUsageIdentifier;
};


struct _CERT_CHAIN_ELEMENT
{
  unsigned int cbSize;
  _CERT_CONTEXT *pCertContext;
  _CERT_TRUST_STATUS TrustStatus;
  _CERT_REVOCATION_INFO *pRevocationInfo;
  _CTL_USAGE *pIssuanceUsage;
  _CTL_USAGE *pApplicationUsage;
  const unsigned __int16 *pwszExtendedErrorInfo;
};


struct _ACTIVATION_CONTEXT_QUERY_INDEX
{
  unsigned int ulAssemblyIndex;
  unsigned int ulFileIndexInAssembly;
};


struct _CRYPT_ATTRIBUTE
{
  char *pszObjId;
  unsigned int cValue;
  _CRYPTOAPI_BLOB *rgValue;
};


struct _CRYPT_ATTRIBUTES
{
  unsigned int cAttr;
  _CRYPT_ATTRIBUTE *rgAttr;
};


struct _CMC_ADD_EXTENSIONS_INFO
{
  unsigned int dwCmcDataReference;
  unsigned int cCertReference;
  unsigned int *rgdwCertReference;
  unsigned int cExtension;
  _CERT_EXTENSION *rgExtension;
};


struct _CRYPT_URL_ARRAY
{
  unsigned int cUrl;
  unsigned __int16 **rgwszUrl;
};


union $726A17CE83E57534AEAE47CF2E04B483
{
  unsigned int Reserved;
  unsigned int TimeDateStamp;
};


struct _MINIDUMP_HEADER
{
  unsigned int Signature;
  unsigned int Version;
  unsigned int NumberOfStreams;
  unsigned int StreamDirectoryRva;
  unsigned int CheckSum;
  $726A17CE83E57534AEAE47CF2E04B483 ___u5;
  unsigned __int64 Flags;
};


struct _OSVERSIONINFOEXW
{
  unsigned int dwOSVersionInfoSize;
  unsigned int dwMajorVersion;
  unsigned int dwMinorVersion;
  unsigned int dwBuildNumber;
  unsigned int dwPlatformId;
  unsigned __int16 szCSDVersion[128];
  unsigned __int16 wServicePackMajor;
  unsigned __int16 wServicePackMinor;
  unsigned __int16 wSuiteMask;
  char wProductType;
  char wReserved;
};


struct _DCB
{
  unsigned int DCBlength;
  unsigned int BaudRate;
  int _bf8;
  unsigned __int16 wReserved;
  unsigned __int16 XonLim;
  unsigned __int16 XoffLim;
  char ByteSize;
  char Parity;
  char StopBits;
  char XonChar;
  char XoffChar;
  char ErrorChar;
  char EofChar;
  char EvtChar;
  unsigned __int16 wReserved1;
};


struct _COMMCONFIG
{
  unsigned int dwSize;
  unsigned __int16 wVersion;
  unsigned __int16 wReserved;
  _DCB dcb;
  unsigned int dwProviderSubType;
  unsigned int dwProviderOffset;
  unsigned int dwProviderSize;
  unsigned __int16 wcProviderData[1];
};


struct tagPALETTEENTRY
{
  char peRed;
  char peGreen;
  char peBlue;
  char peFlags;
};


struct tagPANOSE
{
  char bFamilyType;
  char bSerifStyle;
  char bWeight;
  char bProportion;
  char bContrast;
  char bStrokeVariation;
  char bArmStyle;
  char bLetterform;
  char bMidline;
  char bXHeight;
};


struct tagEXTLOGFONTW
{
  tagLOGFONTW elfLogFont;
  unsigned __int16 elfFullName[64];
  unsigned __int16 elfStyle[32];
  unsigned int elfVersion;
  unsigned int elfStyleSize;
  unsigned int elfMatch;
  unsigned int elfReserved;
  char elfVendorId[4];
  unsigned int elfCulture;
  tagPANOSE elfPanose;
};


struct tagEMREXTCREATEFONTINDIRECTW
{
  tagEMR emr;
  unsigned int ihFont;
  tagEXTLOGFONTW elfw;
};


struct _CRYPT_KEY_PROV_PARAM
{
  unsigned int dwParam;
  char *pbData;
  unsigned int cbData;
  unsigned int dwFlags;
};


struct _CRYPT_KEY_PROV_INFO
{
  unsigned __int16 *pwszContainerName;
  unsigned __int16 *pwszProvName;
  unsigned int dwProvType;
  unsigned int dwFlags;
  unsigned int cProvParam;
  _CRYPT_KEY_PROV_PARAM *rgProvParam;
  unsigned int dwKeySpec;
};


struct _SID_IDENTIFIER_AUTHORITY
{
  char Value[6];
};


struct _IMAGE_BOUND_IMPORT_DESCRIPTOR
{
  unsigned int TimeDateStamp;
  unsigned __int16 OffsetModuleName;
  unsigned __int16 NumberOfModuleForwarderRefs;
};


struct tagEMROFFSETCLIPRGN
{
  tagEMR emr;
  _POINTL ptlOffset;
};


struct tagSCROLLINFO
{
  unsigned int cbSize;
  unsigned int fMask;
  int nMin;
  int nMax;
  unsigned int nPage;
  int nPos;
  int nTrackPos;
};


struct tagREGISTERWORDW
{
  unsigned __int16 *lpReading;
  unsigned __int16 *lpWord;
};


union $444B8AF3F414656C8F88F98B3D40B8AE
{
  unsigned int hKeyEncryptionKey;
  void *pvKeyEncryptionKey;
};


struct _CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO
{
  unsigned int cbSize;
  _CRYPT_ALGORITHM_IDENTIFIER KeyEncryptionAlgorithm;
  void *pvKeyEncryptionAuxInfo;
  unsigned int hCryptProv;
  unsigned int dwKeyChoice;
  $444B8AF3F414656C8F88F98B3D40B8AE ___u5;
  _CRYPTOAPI_BLOB KeyId;
  _FILETIME Date;
  _CRYPT_ATTRIBUTE_TYPE_VALUE *pOtherAttr;
};


struct _LUID
{
  unsigned int LowPart;
  int HighPart;
};


struct _LUID_AND_ATTRIBUTES
{
  _LUID Luid;
  unsigned int Attributes;
};


struct tagRECT
{
  int left;
  int top;
  int right;
  int bottom;
};


struct tagPOLYTEXTA
{
  int x;
  int y;
  unsigned int n;
  const char *lpstr;
  unsigned int uiFlags;
  tagRECT rcl;
  int *pdx;
};


struct tagEMRSELECTOBJECT
{
  tagEMR emr;
  unsigned int ihObject;
};


struct tagEMRPOLYDRAW
{
  tagEMR emr;
  _RECTL rclBounds;
  unsigned int cptl;
  _POINTL aptl[1];
  char abTypes[1];
};


struct tagCOPYDATASTRUCT
{
  unsigned int dwData;
  unsigned int cbData;
  void *lpData;
};


struct tagREGISTERWORDA
{
  char *lpReading;
  char *lpWord;
};


struct _IMAGE_FILE_HEADER
{
  unsigned __int16 Machine;
  unsigned __int16 NumberOfSections;
  unsigned int TimeDateStamp;
  unsigned int PointerToSymbolTable;
  unsigned int NumberOfSymbols;
  unsigned __int16 SizeOfOptionalHeader;
  unsigned __int16 Characteristics;
};


struct _IMAGE_DATA_DIRECTORY
{
  unsigned int VirtualAddress;
  unsigned int Size;
};


struct _IMAGE_OPTIONAL_HEADER
{
  unsigned __int16 Magic;
  char MajorLinkerVersion;
  char MinorLinkerVersion;
  unsigned int SizeOfCode;
  unsigned int SizeOfInitializedData;
  unsigned int SizeOfUninitializedData;
  unsigned int AddressOfEntryPoint;
  unsigned int BaseOfCode;
  unsigned int BaseOfData;
  unsigned int ImageBase;
  unsigned int SectionAlignment;
  unsigned int FileAlignment;
  unsigned __int16 MajorOperatingSystemVersion;
  unsigned __int16 MinorOperatingSystemVersion;
  unsigned __int16 MajorImageVersion;
  unsigned __int16 MinorImageVersion;
  unsigned __int16 MajorSubsystemVersion;
  unsigned __int16 MinorSubsystemVersion;
  unsigned int Win32VersionValue;
  unsigned int SizeOfImage;
  unsigned int SizeOfHeaders;
  unsigned int CheckSum;
  unsigned __int16 Subsystem;
  unsigned __int16 DllCharacteristics;
  unsigned int SizeOfStackReserve;
  unsigned int SizeOfStackCommit;
  unsigned int SizeOfHeapReserve;
  unsigned int SizeOfHeapCommit;
  unsigned int LoaderFlags;
  unsigned int NumberOfRvaAndSizes;
  _IMAGE_DATA_DIRECTORY DataDirectory[16];
};


struct _IMAGE_NT_HEADERS
{
  unsigned int Signature;
  _IMAGE_FILE_HEADER FileHeader;
  _IMAGE_OPTIONAL_HEADER OptionalHeader;
};


union $22971E98F1DCAE471B592EC18ECB1551
{
  unsigned int PhysicalAddress;
  unsigned int VirtualSize;
};


struct _IMAGE_SECTION_HEADER
{
  char Name[8];
  $22971E98F1DCAE471B592EC18ECB1551 Misc;
  unsigned int VirtualAddress;
  unsigned int SizeOfRawData;
  unsigned int PointerToRawData;
  unsigned int PointerToRelocations;
  unsigned int PointerToLinenumbers;
  unsigned __int16 NumberOfRelocations;
  unsigned __int16 NumberOfLinenumbers;
  unsigned int Characteristics;
};


struct _LOADED_IMAGE
{
  char *ModuleName;
  void *hFile;
  char *MappedAddress;
  _IMAGE_NT_HEADERS *FileHeader;
  _IMAGE_SECTION_HEADER *LastRvaSection;
  unsigned int NumberOfSections;
  _IMAGE_SECTION_HEADER *Sections;
  unsigned int Characteristics;
  char fSystemImage;
  char fDOSImage;
  _LIST_ENTRY Links;
  unsigned int SizeOfImage;
};


struct _IMAGE_BOUND_FORWARDER_REF
{
  unsigned int TimeDateStamp;
  unsigned __int16 OffsetModuleName;
  unsigned __int16 Reserved;
};


struct tagMINMAXINFO
{
  tagPOINT ptReserved;
  tagPOINT ptMaxSize;
  tagPOINT ptMaxPosition;
  tagPOINT ptMinTrackSize;
  tagPOINT ptMaxTrackSize;
};


struct _SERVICE_TABLE_ENTRYW
{
  unsigned __int16 *lpServiceName;
  void (__stdcall *lpServiceProc)(unsigned int, unsigned __int16 **);
};


struct _JOBOBJECT_END_OF_JOB_TIME_INFORMATION
{
  unsigned int EndOfJobTimeAction;
};


struct HINSTANCE__
{
  int unused;
};


struct tagDEBUGHOOKINFO
{
  unsigned int idThread;
  unsigned int idThreadInstaller;
  int lParam;
  unsigned int wParam;
  int code;
};


struct _CRYPT_SIGN_MESSAGE_PARA
{
  unsigned int cbSize;
  unsigned int dwMsgEncodingType;
  _CERT_CONTEXT *pSigningCert;
  _CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm;
  void *pvHashAuxInfo;
  unsigned int cMsgCert;
  _CERT_CONTEXT **rgpMsgCert;
  unsigned int cMsgCrl;
  _CRL_CONTEXT **rgpMsgCrl;
  unsigned int cAuthAttr;
  _CRYPT_ATTRIBUTE *rgAuthAttr;
  unsigned int cUnauthAttr;
  _CRYPT_ATTRIBUTE *rgUnauthAttr;
  unsigned int dwFlags;
  unsigned int dwInnerContentType;
};


struct tagWINDOWINFO
{
  unsigned int cbSize;
  tagRECT rcWindow;
  tagRECT rcClient;
  unsigned int dwStyle;
  unsigned int dwExStyle;
  unsigned int dwWindowStatus;
  unsigned int cxWindowBorders;
  unsigned int cyWindowBorders;
  unsigned __int16 atomWindowType;
  unsigned __int16 wCreatorVersion;
};


struct _CMSG_KEY_TRANS_RECIPIENT_INFO
{
  unsigned int dwVersion;
  _CERT_ID RecipientId;
  _CRYPT_ALGORITHM_IDENTIFIER KeyEncryptionAlgorithm;
  _CRYPTOAPI_BLOB EncryptedKey;
};


union $D69F188A98F15D361AD9A0E87EB50039
{
  _CERT_ID OriginatorCertId;
  _CERT_PUBLIC_KEY_INFO OriginatorPublicKeyInfo;
};


struct _CMSG_KEY_AGREE_RECIPIENT_INFO
{
  unsigned int dwVersion;
  unsigned int dwOriginatorChoice;
  $D69F188A98F15D361AD9A0E87EB50039 ___u2;
  _CRYPTOAPI_BLOB UserKeyingMaterial;
  _CRYPT_ALGORITHM_IDENTIFIER KeyEncryptionAlgorithm;
  unsigned int cRecipientEncryptedKeys;
  _CMSG_RECIPIENT_ENCRYPTED_KEY_INFO **rgpRecipientEncryptedKeys;
};


struct _CMSG_MAIL_LIST_RECIPIENT_INFO
{
  unsigned int dwVersion;
  _CRYPTOAPI_BLOB KeyId;
  _CRYPT_ALGORITHM_IDENTIFIER KeyEncryptionAlgorithm;
  _CRYPTOAPI_BLOB EncryptedKey;
  _FILETIME Date;
  _CRYPT_ATTRIBUTE_TYPE_VALUE *pOtherAttr;
};


union $5DB02E39DC778A98A7BE5010ADD7BC71
{
  _CMSG_KEY_TRANS_RECIPIENT_INFO *pKeyTrans;
  _CMSG_KEY_AGREE_RECIPIENT_INFO *pKeyAgree;
  _CMSG_MAIL_LIST_RECIPIENT_INFO *pMailList;
};


struct _CMSG_CMS_RECIPIENT_INFO
{
  unsigned int dwRecipientChoice;
  $5DB02E39DC778A98A7BE5010ADD7BC71 ___u1;
};


struct _IMAGEHLP_MODULE64
{
  unsigned int SizeOfStruct;
  unsigned __int64 BaseOfImage;
  unsigned int ImageSize;
  unsigned int TimeDateStamp;
  unsigned int CheckSum;
  unsigned int NumSyms;
  SYM_TYPE SymType;
  char ModuleName[32];
  char ImageName[256];
  char LoadedImageName[256];
};


struct tagRGBTRIPLE
{
  char rgbtBlue;
  char rgbtGreen;
  char rgbtRed;
};


struct tagEMRSELECTCLIPPATH
{
  tagEMR emr;
  unsigned int iMode;
};


struct _CERT_CHAIN_FIND_BY_ISSUER_PARA
{
  unsigned int cbSize;
  const char *pszUsageIdentifier;
  unsigned int dwKeySpec;
  unsigned int dwAcquirePrivateKeyFlags;
  unsigned int cIssuer;
  _CRYPTOAPI_BLOB *rgIssuer;
  int (__stdcall *pfnFindCallback)(_CERT_CONTEXT *, void *);
  void *pvFindArg;
};


struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD
{
  unsigned int SizeOfStruct;
  unsigned int BaseOfImage;
  unsigned int CheckSum;
  unsigned int TimeDateStamp;
  char FileName[260];
  char Reparse;
  void *hFile;
};


struct _COMSTAT
{
  int _bf0;
  unsigned int cbInQue;
  unsigned int cbOutQue;
};


struct DLGITEMTEMPLATE
{
  unsigned int style;
  unsigned int dwExtendedStyle;
  __int16 x;
  __int16 y;
  __int16 cx;
  __int16 cy;
  unsigned __int16 id;
};


struct _HMAC_Info
{
  unsigned int HashAlgid;
  char *pbInnerString;
  unsigned int cbInnerString;
  char *pbOuterString;
  unsigned int cbOuterString;
};


struct _CMSG_SIGNER_INFO
{
  unsigned int dwVersion;
  _CRYPTOAPI_BLOB Issuer;
  _CRYPTOAPI_BLOB SerialNumber;
  _CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm;
  _CRYPT_ALGORITHM_IDENTIFIER HashEncryptionAlgorithm;
  _CRYPTOAPI_BLOB EncryptedHash;
  _CRYPT_ATTRIBUTES AuthAttrs;
  _CRYPT_ATTRIBUTES UnauthAttrs;
};


struct WINTRUST_SGNR_INFO_
{
  unsigned int cbStruct;
  const unsigned __int16 *pcwszDisplayName;
  _CMSG_SIGNER_INFO *psSignerInfo;
  unsigned int chStores;
  void **pahStores;
};


struct _TOKEN_SOURCE
{
  char SourceName[8];
  _LUID SourceIdentifier;
};


struct _TOKEN_CONTROL
{
  _LUID TokenId;
  _LUID AuthenticationId;
  _LUID ModifiedId;
  _TOKEN_SOURCE TokenSource;
};


struct _DISPLAY_DEVICEW
{
  unsigned int cb;
  unsigned __int16 DeviceName[32];
  unsigned __int16 DeviceString[128];
  unsigned int StateFlags;
  unsigned __int16 DeviceID[128];
  unsigned __int16 DeviceKey[128];
};


struct tagABORTPATH
{
  tagEMR emr;
};


struct _COORD
{
  __int16 X;
  __int16 Y;
};


struct _SMALL_RECT
{
  __int16 Left;
  __int16 Top;
  __int16 Right;
  __int16 Bottom;
};


struct _CONSOLE_SCREEN_BUFFER_INFO
{
  _COORD dwSize;
  _COORD dwCursorPosition;
  unsigned __int16 wAttributes;
  _SMALL_RECT srWindow;
  _COORD dwMaximumWindowSize;
};


struct _CRYPT_OID_FUNC_ENTRY
{
  const char *pszOID;
  void *pvFuncAddr;
};


struct tagCOLORCORRECTPALETTE
{
  tagEMR emr;
  unsigned int ihPalette;
  unsigned int nFirstEntry;
  unsigned int nPalEntries;
  unsigned int nReserved;
};


struct HMENU__
{
  int unused;
};


struct tagCREATESTRUCTA
{
  void *lpCreateParams;
  HINSTANCE__ *hInstance;
  HMENU__ *hMenu;
  HWND__ *hwndParent;
  int cy;
  int cx;
  int y;
  int x;
  int style;
  const char *lpszName;
  const char *lpszClass;
  unsigned int dwExStyle;
};


struct tagMINIMIZEDMETRICS
{
  unsigned int cbSize;
  int iWidth;
  int iHorzGap;
  int iVertGap;
  int iArrange;
};


struct _CRYPT_DECRYPT_MESSAGE_PARA
{
  unsigned int cbSize;
  unsigned int dwMsgAndCertEncodingType;
  unsigned int cCertStore;
  void **rghCertStore;
};


struct _TypeDescriptor
{
  const void *pVFTable;
  void *spare;
  char name[];
};


struct _PMD
{
  int mdisp;
  int pdisp;
  int vdisp;
};


struct _s__CatchableType
{
  unsigned int properties;
  _TypeDescriptor *pType;
  _PMD thisDisplacement;
  int sizeOrOffset;
  void (__cdecl *copyFunction)();
};


struct _s__CatchableTypeArray
{
  int nCatchableTypes;
  _s__CatchableType *arrayOfCatchableTypes[];
};


struct tagCIEXYZ
{
  int ciexyzX;
  int ciexyzY;
  int ciexyzZ;
};


struct tagICEXYZTRIPLE
{
  tagCIEXYZ ciexyzRed;
  tagCIEXYZ ciexyzGreen;
  tagCIEXYZ ciexyzBlue;
};


struct tagLOGCOLORSPACEW
{
  unsigned int lcsSignature;
  unsigned int lcsVersion;
  unsigned int lcsSize;
  int lcsCSType;
  int lcsIntent;
  tagICEXYZTRIPLE lcsEndpoints;
  unsigned int lcsGammaRed;
  unsigned int lcsGammaGreen;
  unsigned int lcsGammaBlue;
  unsigned __int16 lcsFilename[260];
};


struct tagEMRCREATECOLORSPACEW
{
  tagEMR emr;
  unsigned int ihCS;
  tagLOGCOLORSPACEW lcs;
  unsigned int dwFlags;
  unsigned int cbData;
  char Data[1];
};


struct _CTL_ENTRY
{
  _CRYPTOAPI_BLOB SubjectIdentifier;
  unsigned int cAttribute;
  _CRYPT_ATTRIBUTE *rgAttribute;
};


struct _CTL_INFO
{
  unsigned int dwVersion;
  _CTL_USAGE SubjectUsage;
  _CRYPTOAPI_BLOB ListIdentifier;
  _CRYPTOAPI_BLOB SequenceNumber;
  _FILETIME ThisUpdate;
  _FILETIME NextUpdate;
  _CRYPT_ALGORITHM_IDENTIFIER SubjectAlgorithm;
  unsigned int cCTLEntry;
  _CTL_ENTRY *rgCTLEntry;
  unsigned int cExtension;
  _CERT_EXTENSION *rgExtension;
};


struct _CTL_CONTEXT
{
  unsigned int dwMsgAndCertEncodingType;
  char *pbCtlEncoded;
  unsigned int cbCtlEncoded;
  _CTL_INFO *pCtlInfo;
  void *hCertStore;
  void *hCryptMsg;
  char *pbCtlContent;
  unsigned int cbCtlContent;
};


struct _CTL_VERIFY_USAGE_STATUS
{
  unsigned int cbSize;
  unsigned int dwError;
  unsigned int dwFlags;
  _CTL_CONTEXT **ppCtl;
  unsigned int dwCtlEntryIndex;
  _CERT_CONTEXT **ppSigner;
  unsigned int dwSignerIndex;
};


struct _CRYPT_BLOB_ARRAY
{
  unsigned int cBlob;
  _CRYPTOAPI_BLOB *rgBlob;
};


struct _CERT_TRUST_LIST_INFO
{
  unsigned int cbSize;
  _CTL_ENTRY *pCtlEntry;
  _CTL_CONTEXT *pCtlContext;
};


struct _CERT_SIMPLE_CHAIN
{
  unsigned int cbSize;
  _CERT_TRUST_STATUS TrustStatus;
  unsigned int cElement;
  _CERT_CHAIN_ELEMENT **rgpElement;
  _CERT_TRUST_LIST_INFO *pTrustListInfo;
  int fHasRevocationFreshnessTime;
  unsigned int dwRevocationFreshnessTime;
};


struct _CERT_CHAIN_CONTEXT
{
  unsigned int cbSize;
  _CERT_TRUST_STATUS TrustStatus;
  unsigned int cChain;
  _CERT_SIMPLE_CHAIN **rgpChain;
  unsigned int cLowerQualityChainContext;
  _CERT_CHAIN_CONTEXT **rgpLowerQualityChainContext;
  int fHasRevocationFreshnessTime;
  unsigned int dwRevocationFreshnessTime;
};


struct tagEMRFILLRGN
{
  tagEMR emr;
  _RECTL rclBounds;
  unsigned int cbRgnData;
  unsigned int ihBrush;
  char RgnData[1];
};


struct tagMULTIKEYHELPW
{
  unsigned int mkSize;
  unsigned __int16 mkKeylist;
  unsigned __int16 szKeyphrase[1];
};


struct tagHELPWININFOA
{
  int wStructSize;
  int x;
  int y;
  int dx;
  int dy;
  int wMax;
  char rgchMember[2];
};


struct tagSIZE
{
  int cx;
  int cy;
};


struct tagEMRFRAMERGN
{
  tagEMR emr;
  _RECTL rclBounds;
  unsigned int cbRgnData;
  unsigned int ihBrush;
  tagSIZE szlStroke;
  char RgnData[1];
};


struct tagMEASUREITEMSTRUCT
{
  unsigned int CtlType;
  unsigned int CtlID;
  unsigned int itemID;
  unsigned int itemWidth;
  unsigned int itemHeight;
  unsigned int itemData;
};


struct _CERT_LDAP_STORE_OPENED_PARA
{
  void *pvLdapSessionHandle;
  const unsigned __int16 *pwszLdapUrl;
};


struct _CREATE_PROCESS_DEBUG_INFO
{
  void *hFile;
  void *hProcess;
  void *hThread;
  void *lpBaseOfImage;
  unsigned int dwDebugInfoFileOffset;
  unsigned int nDebugInfoSize;
  void *lpThreadLocalBase;
  unsigned int (__stdcall *lpStartAddress)(void *);
  void *lpImageName;
  unsigned __int16 fUnicode;
};


struct _CERT_POLICY_QUALIFIER_NOTICE_REFERENCE
{
  char *pszOrganization;
  unsigned int cNoticeNumbers;
  int *rgNoticeNumbers;
};


struct _CERT_POLICY_QUALIFIER_USER_NOTICE
{
  _CERT_POLICY_QUALIFIER_NOTICE_REFERENCE *pNoticeReference;
  unsigned __int16 *pszDisplayText;
};


struct _IMAGEHLP_MODULEW
{
  unsigned int SizeOfStruct;
  unsigned int BaseOfImage;
  unsigned int ImageSize;
  unsigned int TimeDateStamp;
  unsigned int CheckSum;
  unsigned int NumSyms;
  SYM_TYPE SymType;
  unsigned __int16 ModuleName[32];
  unsigned __int16 ImageName[256];
  unsigned __int16 LoadedImageName[256];
};


struct _ACE_HEADER
{
  char AceType;
  char AceFlags;
  unsigned __int16 AceSize;
};


struct HGLRC__
{
  int unused;
};


struct tagEMREXCLUDECLIPRECT
{
  tagEMR emr;
  _RECTL rclClip;
};


struct tagEMRPOLYPOLYLINE
{
  tagEMR emr;
  _RECTL rclBounds;
  unsigned int nPolys;
  unsigned int cptl;
  unsigned int aPolyCounts[1];
  _POINTL aptl[1];
};


struct tagUSEROBJECTFLAGS
{
  int fInherit;
  int fReserved;
  unsigned int dwFlags;
};


struct fd_set
{
  unsigned int fd_count;
  unsigned int fd_array[64];
};


struct _CMSG_CTRL_MAIL_LIST_DECRYPT_PARA
{
  unsigned int cbSize;
  unsigned int hCryptProv;
  _CMSG_MAIL_LIST_RECIPIENT_INFO *pMailList;
  unsigned int dwRecipientIndex;
  unsigned int dwKeyChoice;
  $444B8AF3F414656C8F88F98B3D40B8AE ___u5;
};


struct _NON_PAGED_DEBUG_INFO
{
  unsigned __int16 Signature;
  unsigned __int16 Flags;
  unsigned int Size;
  unsigned __int16 Machine;
  unsigned __int16 Characteristics;
  unsigned int TimeDateStamp;
  unsigned int CheckSum;
  unsigned int SizeOfImage;
  unsigned __int64 ImageBase;
};


struct _CRYPT_CREDENTIALS
{
  unsigned int cbSize;
  const char *pszCredentialsOid;
  void *pvCredentials;
};


struct _CRYPT_HASH_INFO
{
  _CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm;
  _CRYPTOAPI_BLOB Hash;
};


struct _CERT_OTHER_NAME
{
  char *pszObjId;
  _CRYPTOAPI_BLOB Value;
};


union $41CEE4C7C1F12FB93E87B8B3E249D39B
{
  _CERT_OTHER_NAME *pOtherName;
  unsigned __int16 *pwszRfc822Name;
  unsigned __int16 *pwszDNSName;
  _CRYPTOAPI_BLOB DirectoryName;
  unsigned __int16 *pwszURL;
  _CRYPTOAPI_BLOB IPAddress;
  char *pszRegisteredID;
};


struct _CERT_ALT_NAME_ENTRY
{
  unsigned int dwAltNameChoice;
  $41CEE4C7C1F12FB93E87B8B3E249D39B ___u1;
};


struct _CERT_ACCESS_DESCRIPTION
{
  char *pszAccessMethod;
  _CERT_ALT_NAME_ENTRY AccessLocation;
};


struct WINTRUST_BLOB_INFO_
{
  unsigned int cbStruct;
  _GUID gSubject;
  const unsigned __int16 *pcwszDisplayName;
  unsigned int cbMemObject;
  char *pbMemObject;
  unsigned int cbMemSignedMsg;
  char *pbMemSignedMsg;
};


struct HRGN__
{
  int unused;
};


struct _CERT_SIGNED_CONTENT_INFO
{
  _CRYPTOAPI_BLOB ToBeSigned;
  _CRYPT_ALGORITHM_IDENTIFIER SignatureAlgorithm;
  _CRYPT_BIT_BLOB Signature;
};


struct _CMC_TAGGED_ATTRIBUTE
{
  unsigned int dwBodyPartID;
  _CRYPT_ATTRIBUTE Attribute;
};


struct _CRYPT_PROVIDER_DEFUSAGE
{
  unsigned int cbStruct;
  _GUID gActionID;
  void *pDefPolicyCallbackData;
  void *pDefSIPClientData;
};


struct _JOBOBJECT_JOBSET_INFORMATION
{
  unsigned int MemberLevel;
};


struct _WIN_TRUST_ACTDATA_CONTEXT_WITH_SUBJECT
{
  void *hClientToken;
  _GUID *SubjectType;
  void *Subject;
};


struct $FAF74743FBE1C8632047CFB668F7028A
{
  unsigned int LowPart;
  int HighPart;
};


union _LARGE_INTEGER
{
  $FAF74743FBE1C8632047CFB668F7028A _s0;
  $FAF74743FBE1C8632047CFB668F7028A u;
  __int64 QuadPart;
};


struct CM_Power_Data_s
{
  unsigned int PD_Size;
  _DEVICE_POWER_STATE PD_MostRecentPowerState;
  unsigned int PD_Capabilities;
  unsigned int PD_D1Latency;
  unsigned int PD_D2Latency;
  unsigned int PD_D3Latency;
  _DEVICE_POWER_STATE PD_PowerStateMapping[7];
  _SYSTEM_POWER_STATE PD_DeepestSystemWake;
};


struct BITMAPV5HEADER
{
  unsigned int bV5Size;
  int bV5Width;
  int bV5Height;
  unsigned __int16 bV5Planes;
  unsigned __int16 bV5BitCount;
  unsigned int bV5Compression;
  unsigned int bV5SizeImage;
  int bV5XPelsPerMeter;
  int bV5YPelsPerMeter;
  unsigned int bV5ClrUsed;
  unsigned int bV5ClrImportant;
  unsigned int bV5RedMask;
  unsigned int bV5GreenMask;
  unsigned int bV5BlueMask;
  unsigned int bV5AlphaMask;
  unsigned int bV5CSType;
  tagICEXYZTRIPLE bV5Endpoints;
  unsigned int bV5GammaRed;
  unsigned int bV5GammaGreen;
  unsigned int bV5GammaBlue;
  unsigned int bV5Intent;
  unsigned int bV5ProfileData;
  unsigned int bV5ProfileSize;
  unsigned int bV5Reserved;
};


struct tagANIMATIONINFO
{
  unsigned int cbSize;
  int iMinAnimate;
};


struct _CTL_FIND_USAGE_PARA
{
  unsigned int cbSize;
  _CTL_USAGE SubjectUsage;
  _CRYPTOAPI_BLOB ListIdentifier;
  _CERT_INFO *pSigner;
};


struct _CTL_FIND_SUBJECT_PARA
{
  unsigned int cbSize;
  _CTL_FIND_USAGE_PARA *pUsagePara;
  unsigned int dwSubjectType;
  void *pvSubject;
};


struct _MINIDUMP_HANDLE_DATA_STREAM
{
  unsigned int SizeOfHeader;
  unsigned int SizeOfDescriptor;
  unsigned int NumberOfDescriptors;
  unsigned int Reserved;
};


struct _VIDEOPARAMETERS
{
  _GUID Guid;
  unsigned int dwOffset;
  unsigned int dwCommand;
  unsigned int dwFlags;
  unsigned int dwMode;
  unsigned int dwTVStandard;
  unsigned int dwAvailableModes;
  unsigned int dwAvailableTVStandard;
  unsigned int dwFlickerFilter;
  unsigned int dwOverScanX;
  unsigned int dwOverScanY;
  unsigned int dwMaxUnscaledX;
  unsigned int dwMaxUnscaledY;
  unsigned int dwPositionX;
  unsigned int dwPositionY;
  unsigned int dwBrightness;
  unsigned int dwContrast;
  unsigned int dwCPType;
  unsigned int dwCPCommand;
  unsigned int dwCPStandard;
  unsigned int dwCPKey;
  unsigned int bCP_APSTriggerBits;
  char bOEMCopyProtection[256];
};


struct _CMC_TAGGED_CONTENT_INFO
{
  unsigned int dwBodyPartID;
  _CRYPTOAPI_BLOB EncodedContentInfo;
};


struct _CMC_TAGGED_OTHER_MSG
{
  unsigned int dwBodyPartID;
  char *pszObjId;
  _CRYPTOAPI_BLOB Value;
};


struct _CMC_RESPONSE_INFO
{
  unsigned int cTaggedAttribute;
  _CMC_TAGGED_ATTRIBUTE *rgTaggedAttribute;
  unsigned int cTaggedContentInfo;
  _CMC_TAGGED_CONTENT_INFO *rgTaggedContentInfo;
  unsigned int cTaggedOtherMsg;
  _CMC_TAGGED_OTHER_MSG *rgTaggedOtherMsg;
};


struct tagBITMAPCOREHEADER
{
  unsigned int bcSize;
  unsigned __int16 bcWidth;
  unsigned __int16 bcHeight;
  unsigned __int16 bcPlanes;
  unsigned __int16 bcBitCount;
};


struct tagBITMAPCOREINFO
{
  tagBITMAPCOREHEADER bmciHeader;
  tagRGBTRIPLE bmciColors[1];
};


struct tagPIXELFORMATDESCRIPTOR
{
  unsigned __int16 nSize;
  unsigned __int16 nVersion;
  unsigned int dwFlags;
  char iPixelType;
  char cColorBits;
  char cRedBits;
  char cRedShift;
  char cGreenBits;
  char cGreenShift;
  char cBlueBits;
  char cBlueShift;
  char cAlphaBits;
  char cAlphaShift;
  char cAccumBits;
  char cAccumRedBits;
  char cAccumGreenBits;
  char cAccumBlueBits;
  char cAccumAlphaBits;
  char cDepthBits;
  char cStencilBits;
  char cAuxBuffers;
  char iLayerType;
  char bReserved;
  unsigned int dwLayerMask;
  unsigned int dwVisibleMask;
  unsigned int dwDamageMask;
};


struct tagEMRFILLPATH
{
  tagEMR emr;
  _RECTL rclBounds;
};


struct _WSAPROTOCOLCHAIN
{
  int ChainLen;
  unsigned int ChainEntries[7];
};


struct _WSAPROTOCOL_INFOA
{
  unsigned int dwServiceFlags1;
  unsigned int dwServiceFlags2;
  unsigned int dwServiceFlags3;
  unsigned int dwServiceFlags4;
  unsigned int dwProviderFlags;
  _GUID ProviderId;
  unsigned int dwCatalogEntryId;
  _WSAPROTOCOLCHAIN ProtocolChain;
  int iVersion;
  int iAddressFamily;
  int iMaxSockAddr;
  int iMinSockAddr;
  int iSocketType;
  int iProtocol;
  int iProtocolMaxOffset;
  int iNetworkByteOrder;
  int iSecurityScheme;
  unsigned int dwMessageSize;
  unsigned int dwProviderReserved;
  char szProtocol[256];
};


struct WINTRUST_FILE_INFO_
{
  unsigned int cbStruct;
  const unsigned __int16 *pcwszFilePath;
  void *hFile;
  _GUID *pgKnownSubject;
};


struct WINTRUST_CATALOG_INFO_
{
  unsigned int cbStruct;
  unsigned int dwCatalogVersion;
  const unsigned __int16 *pcwszCatalogFilePath;
  const unsigned __int16 *pcwszMemberTag;
  const unsigned __int16 *pcwszMemberFilePath;
  void *hMemberFile;
  char *pbCalculatedFileHash;
  unsigned int cbCalculatedFileHash;
  _CTL_CONTEXT *pcCatalogContext;
};


struct WINTRUST_CERT_INFO_
{
  unsigned int cbStruct;
  const unsigned __int16 *pcwszDisplayName;
  _CERT_CONTEXT *psCertContext;
  unsigned int chStores;
  void **pahStores;
  unsigned int dwFlags;
  _FILETIME *psftVerifyAsOf;
};


union $8F133BE43DD94D8CF9E82C2869D3833B
{
  WINTRUST_FILE_INFO_ *pFile;
  WINTRUST_CATALOG_INFO_ *pCatalog;
  WINTRUST_BLOB_INFO_ *pBlob;
  WINTRUST_SGNR_INFO_ *pSgnr;
  WINTRUST_CERT_INFO_ *pCert;
};


struct _WINTRUST_DATA
{
  unsigned int cbStruct;
  void *pPolicyCallbackData;
  void *pSIPClientData;
  unsigned int dwUIChoice;
  unsigned int fdwRevocationChecks;
  unsigned int dwUnionChoice;
  $8F133BE43DD94D8CF9E82C2869D3833B ___u6;
  unsigned int dwStateAction;
  void *hWVTStateData;
  unsigned __int16 *pwszURLReference;
  unsigned int dwProvFlags;
};


struct _CRYPT_PROVIDER_DATA
{
  unsigned int cbStruct;
  _WINTRUST_DATA *pWintrustData;
  int fOpenedFile;
  HWND__ *hWndParent;
  _GUID *pgActionID;
  unsigned int hProv;
  unsigned int dwError;
  unsigned int dwRegSecuritySettings;
  unsigned int dwRegPolicySettings;
  _CRYPT_PROVIDER_FUNCTIONS *psPfns;
  unsigned int cdwTrustStepErrors;
  unsigned int *padwTrustStepErrors;
  unsigned int chStores;
  void **pahStores;
  unsigned int dwEncoding;
  void *hMsg;
  unsigned int csSigners;
  _CRYPT_PROVIDER_SGNR *pasSigners;
  unsigned int csProvPrivData;
  _CRYPT_PROVIDER_PRIVDATA *pasProvPrivData;
  unsigned int dwSubjectChoice;
  _PROVDATA_SIP *pPDSip;
  char *pszUsageOID;
  int fRecallWithState;
  _FILETIME sftSystemTime;
  char *pszCTLSignerUsageOID;
  unsigned int dwProvFlags;
  unsigned int dwFinalError;
  _CERT_USAGE_MATCH *pRequestUsage;
  unsigned int dwTrustPubSettings;
};


struct _CRYPT_PROVIDER_CERT
{
  unsigned int cbStruct;
  _CERT_CONTEXT *pCert;
  int fCommercial;
  int fTrustedRoot;
  int fSelfSigned;
  int fTestCert;
  unsigned int dwRevokedReason;
  unsigned int dwConfidence;
  unsigned int dwError;
  _CTL_CONTEXT *pTrustListContext;
  int fTrustListSignerCert;
  _CTL_CONTEXT *pCtlContext;
  unsigned int dwCtlError;
  int fIsCyclic;
  _CERT_CHAIN_ELEMENT *pChainElement;
};


struct _CRYPT_PROVIDER_SGNR
{
  unsigned int cbStruct;
  _FILETIME sftVerifyAsOf;
  unsigned int csCertChain;
  _CRYPT_PROVIDER_CERT *pasCertChain;
  unsigned int dwSignerType;
  _CMSG_SIGNER_INFO *psSigner;
  unsigned int dwError;
  unsigned int csCounterSigners;
  _CRYPT_PROVIDER_SGNR *pasCounterSigners;
  _CERT_CHAIN_CONTEXT *pChainContext;
};


struct _CRYPT_PROVIDER_PRIVDATA
{
  unsigned int cbStruct;
  _GUID gProviderID;
  unsigned int cbProvData;
  void *pvProvData;
};


struct _CRYPT_PROVUI_DATA
{
  unsigned int cbStruct;
  unsigned int dwFinalError;
  unsigned __int16 *pYesButtonText;
  unsigned __int16 *pNoButtonText;
  unsigned __int16 *pMoreInfoButtonText;
  unsigned __int16 *pAdvancedLinkText;
  unsigned __int16 *pCopyActionText;
  unsigned __int16 *pCopyActionTextNoTS;
  unsigned __int16 *pCopyActionTextNotSigned;
};


struct _CRYPT_PROVUI_FUNCS
{
  unsigned int cbStruct;
  _CRYPT_PROVUI_DATA *psUIData;
  int (__cdecl *pfnOnMoreInfoClick)(HWND__ *, _CRYPT_PROVIDER_DATA *);
  int (__cdecl *pfnOnMoreInfoClickDefault)(HWND__ *, _CRYPT_PROVIDER_DATA *);
  int (__cdecl *pfnOnAdvancedClick)(HWND__ *, _CRYPT_PROVIDER_DATA *);
  int (__cdecl *pfnOnAdvancedClickDefault)(HWND__ *, _CRYPT_PROVIDER_DATA *);
};


struct _CRYPT_PROVIDER_FUNCTIONS
{
  unsigned int cbStruct;
  void *(__cdecl *pfnAlloc)(unsigned int);
  void (__cdecl *pfnFree)(void *);
  int (__cdecl *pfnAddStore2Chain)(_CRYPT_PROVIDER_DATA *, void *);
  int (__cdecl *pfnAddSgnr2Chain)(_CRYPT_PROVIDER_DATA *, int, unsigned int, _CRYPT_PROVIDER_SGNR *);
  int (__cdecl *pfnAddCert2Chain)(_CRYPT_PROVIDER_DATA *, unsigned int, int, unsigned int, _CERT_CONTEXT *);
  int (__cdecl *pfnAddPrivData2Chain)(_CRYPT_PROVIDER_DATA *, _CRYPT_PROVIDER_PRIVDATA *);
  HRESULT (__cdecl *pfnInitialize)(_CRYPT_PROVIDER_DATA *);
  HRESULT (__cdecl *pfnObjectTrust)(_CRYPT_PROVIDER_DATA *);
  HRESULT (__cdecl *pfnSignatureTrust)(_CRYPT_PROVIDER_DATA *);
  HRESULT (__cdecl *pfnCertificateTrust)(_CRYPT_PROVIDER_DATA *);
  HRESULT (__cdecl *pfnFinalPolicy)(_CRYPT_PROVIDER_DATA *);
  int (__cdecl *pfnCertCheckPolicy)(_CRYPT_PROVIDER_DATA *, unsigned int, int, unsigned int);
  HRESULT (__cdecl *pfnTestFinalPolicy)(_CRYPT_PROVIDER_DATA *);
  _CRYPT_PROVUI_FUNCS *psUIpfns;
  HRESULT (__cdecl *pfnCleanupPolicy)(_CRYPT_PROVIDER_DATA *);
};


struct _PROVDATA_SIP
{
  unsigned int cbStruct;
  _GUID gSubject;
  struct SIP_DISPATCH_INFO_ *pSip;
  struct SIP_DISPATCH_INFO_ *pCATSip;
  struct SIP_SUBJECTINFO_ *psSipSubjectInfo;
  struct SIP_SUBJECTINFO_ *psSipCATSubjectInfo;
  struct SIP_INDIRECT_DATA_ *psIndirectData;
};


struct _CERT_USAGE_MATCH
{
  unsigned int dwType;
  _CTL_USAGE Usage;
};


struct _MINIDUMP_EXCEPTION
{
  unsigned int ExceptionCode;
  unsigned int ExceptionFlags;
  unsigned __int64 ExceptionRecord;
  unsigned __int64 ExceptionAddress;
  unsigned int NumberParameters;
  unsigned int __unusedAlignment;
  unsigned __int64 ExceptionInformation[15];
};


struct _MINIDUMP_LOCATION_DESCRIPTOR
{
  unsigned int DataSize;
  unsigned int Rva;
};


struct MINIDUMP_EXCEPTION_STREAM
{
  unsigned int ThreadId;
  unsigned int __alignment;
  _MINIDUMP_EXCEPTION ExceptionRecord;
  _MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
};


struct _FLOAT128
{
  __int64 LowPart;
  __int64 HighPart;
};


struct _LDT_ENTRY::__unnamed::__unnamed
{
  char BaseMid;
  char Flags1;
  char Flags2;
  char BaseHi;
};


union _LDT_ENTRY::__unnamed
{
  _LDT_ENTRY::__unnamed::__unnamed Bytes;
  _LDT_ENTRY::__unnamed::__unnamed Bits;
};


struct _LDT_ENTRY
{
  unsigned __int16 LimitLow;
  unsigned __int16 BaseLow;
  _LDT_ENTRY::__unnamed HighWord;
};


struct _JOBOBJECT_BASIC_LIMIT_INFORMATION
{
  _LARGE_INTEGER PerProcessUserTimeLimit;
  _LARGE_INTEGER PerJobUserTimeLimit;
  unsigned int LimitFlags;
  unsigned int MinimumWorkingSetSize;
  unsigned int MaximumWorkingSetSize;
  unsigned int ActiveProcessLimit;
  unsigned int Affinity;
  unsigned int PriorityClass;
  unsigned int SchedulingClass;
};


struct tagMETAHEADER
{
  unsigned __int16 mtType;
  unsigned __int16 mtHeaderSize;
  unsigned __int16 mtVersion;
  unsigned int mtSize;
  unsigned __int16 mtNoObjects;
  unsigned int mtMaxRecord;
  unsigned __int16 mtNoParameters;
};


struct HICON__
{
  int unused;
};


struct HBRUSH__
{
  int unused;
};


struct tagWNDCLASSEXA
{
  unsigned int cbSize;
  unsigned int style;
  int (__stdcall *lpfnWndProc)(HWND__ *, unsigned int, unsigned int, int);
  int cbClsExtra;
  int cbWndExtra;
  HINSTANCE__ *hInstance;
  HICON__ *hIcon;
  HICON__ *hCursor;
  HBRUSH__ *hbrBackground;
  const char *lpszMenuName;
  const char *lpszClassName;
  HICON__ *hIconSm;
};


struct _CRYPT_SMIME_CAPABILITY
{
  char *pszObjId;
  _CRYPTOAPI_BLOB Parameters;
};


struct _CRYPT_SMIME_CAPABILITIES
{
  unsigned int cCapability;
  _CRYPT_SMIME_CAPABILITY *rgCapability;
};


struct _AUTHENTICODE_TS_EXTRA_CERT_CHAIN_POLICY_PARA
{
  unsigned int cbSize;
  unsigned int dwRegPolicySettings;
  int fCommercial;
};


struct HKL__
{
  int unused;
};


struct tagLOGFONTA
{
  int lfHeight;
  int lfWidth;
  int lfEscapement;
  int lfOrientation;
  int lfWeight;
  char lfItalic;
  char lfUnderline;
  char lfStrikeOut;
  char lfCharSet;
  char lfOutPrecision;
  char lfClipPrecision;
  char lfQuality;
  char lfPitchAndFamily;
  char lfFaceName[32];
};


struct tagCWPRETSTRUCT
{
  int lResult;
  int lParam;
  unsigned int wParam;
  unsigned int message;
  HWND__ *hwnd;
};


struct HIMCC__
{
  int unused;
};


struct _MEMORY_BASIC_INFORMATION32
{
  unsigned int BaseAddress;
  unsigned int AllocationBase;
  unsigned int AllocationProtect;
  unsigned int RegionSize;
  unsigned int State;
  unsigned int Protect;
  unsigned int Type;
};


struct tagENHMETARECORD
{
  unsigned int iType;
  unsigned int nSize;
  unsigned int dParm[1];
};


struct tagTEXTMETRICA
{
  int tmHeight;
  int tmAscent;
  int tmDescent;
  int tmInternalLeading;
  int tmExternalLeading;
  int tmAveCharWidth;
  int tmMaxCharWidth;
  int tmWeight;
  int tmOverhang;
  int tmDigitizedAspectX;
  int tmDigitizedAspectY;
  char tmFirstChar;
  char tmLastChar;
  char tmDefaultChar;
  char tmBreakChar;
  char tmItalic;
  char tmUnderlined;
  char tmStruckOut;
  char tmPitchAndFamily;
  char tmCharSet;
};


struct _MINIDUMP_FUNCTION_TABLE_DESCRIPTOR
{
  unsigned __int64 MinimumAddress;
  unsigned __int64 MaximumAddress;
  unsigned __int64 BaseAddress;
  unsigned int EntryCount;
  unsigned int SizeOfAlignPad;
};


struct HWINSTA__
{
  int unused;
};


struct _OFSTRUCT
{
  char cBytes;
  char fFixedDisk;
  unsigned __int16 nErrCode;
  unsigned __int16 Reserved1;
  unsigned __int16 Reserved2;
  char szPathName[128];
};


struct _FIXED
{
  unsigned __int16 fract;
  __int16 value;
};


struct _MAT2
{
  _FIXED eM11;
  _FIXED eM12;
  _FIXED eM21;
  _FIXED eM22;
};


struct tagEMRNAMEDESCAPE
{
  tagEMR emr;
  int iEscape;
  int cbDriver;
  int cbEscData;
  char EscData[1];
};


struct tagHELPINFO
{
  unsigned int cbSize;
  int iContextType;
  int iCtrlId;
  void *hItemHandle;
  unsigned int dwContextId;
  tagPOINT MousePos;
};


struct tagMSGBOXPARAMSA
{
  unsigned int cbSize;
  HWND__ *hwndOwner;
  HINSTANCE__ *hInstance;
  const char *lpszText;
  const char *lpszCaption;
  unsigned int dwStyle;
  const char *lpszIcon;
  unsigned int dwContextHelpId;
  void (__stdcall *lpfnMsgBoxCallback)(tagHELPINFO *);
  unsigned int dwLanguageId;
};


struct tagCLIENTCREATESTRUCT
{
  void *hWindowMenu;
  unsigned int idFirstChild;
};


struct _IMAGEHLP_SYMBOL64
{
  unsigned int SizeOfStruct;
  unsigned __int64 Address;
  unsigned int Size;
  unsigned int Flags;
  unsigned int MaxNameLength;
  char Name[1];
};


struct _OUTPUT_DEBUG_STRING_INFO
{
  char *lpDebugStringData;
  unsigned __int16 fUnicode;
  unsigned __int16 nDebugStringLength;
};


struct tagEVENTMSG
{
  unsigned int message;
  unsigned int paramL;
  unsigned int paramH;
  unsigned int time;
  HWND__ *hwnd;
};


struct _UNIVERSAL_NAME_INFOA
{
  char *lpUniversalName;
};


struct _IMAGE_OPTIONAL_HEADER64
{
  unsigned __int16 Magic;
  char MajorLinkerVersion;
  char MinorLinkerVersion;
  unsigned int SizeOfCode;
  unsigned int SizeOfInitializedData;
  unsigned int SizeOfUninitializedData;
  unsigned int AddressOfEntryPoint;
  unsigned int BaseOfCode;
  unsigned __int64 ImageBase;
  unsigned int SectionAlignment;
  unsigned int FileAlignment;
  unsigned __int16 MajorOperatingSystemVersion;
  unsigned __int16 MinorOperatingSystemVersion;
  unsigned __int16 MajorImageVersion;
  unsigned __int16 MinorImageVersion;
  unsigned __int16 MajorSubsystemVersion;
  unsigned __int16 MinorSubsystemVersion;
  unsigned int Win32VersionValue;
  unsigned int SizeOfImage;
  unsigned int SizeOfHeaders;
  unsigned int CheckSum;
  unsigned __int16 Subsystem;
  unsigned __int16 DllCharacteristics;
  unsigned __int64 SizeOfStackReserve;
  unsigned __int64 SizeOfStackCommit;
  unsigned __int64 SizeOfHeapReserve;
  unsigned __int64 SizeOfHeapCommit;
  unsigned int LoaderFlags;
  unsigned int NumberOfRvaAndSizes;
  _IMAGE_DATA_DIRECTORY DataDirectory[16];
};


struct tagEMRSETVIEWPORTEXTEX
{
  tagEMR emr;
  tagSIZE szlExtent;
};


struct tagTRACKMOUSEEVENT
{
  unsigned int cbSize;
  unsigned int dwFlags;
  HWND__ *hwndTrack;
  unsigned int dwHoverTime;
};


struct tagCOMBOBOXINFO
{
  unsigned int cbSize;
  tagRECT rcItem;
  tagRECT rcButton;
  unsigned int stateButton;
  HWND__ *hwndCombo;
  HWND__ *hwndItem;
  HWND__ *hwndList;
};


const struct _s__RTTIBaseClassDescriptor
{
  _TypeDescriptor *pTypeDescriptor;
  unsigned int numContainedBases;
  _PMD where;
  unsigned int attributes;
};


const struct _s__RTTIBaseClassArray
{
  _s__RTTIBaseClassDescriptor *arrayOfBaseClassDescriptors[];
  _BYTE gap0[1];
};


struct _s__RTTIClassHierarchyDescriptor
{
  unsigned int signature;
  unsigned int attributes;
  unsigned int numBaseClasses;
  _s__RTTIBaseClassArray *pBaseClassArray;
};


struct _s__RTTICompleteObjectLocator
{
  unsigned int signature;
  unsigned int offset;
  unsigned int cdOffset;
  _TypeDescriptor *pTypeDescriptor;
  _s__RTTIClassHierarchyDescriptor *pClassDescriptor;
};


struct _IMAGE_AUX_SYMBOL::__unnamed::__unnamed::__unnamed
{
  unsigned __int16 Linenumber;
  unsigned __int16 Size;
};


union _IMAGE_AUX_SYMBOL::__unnamed::__unnamed
{
  _IMAGE_AUX_SYMBOL::__unnamed::__unnamed::__unnamed LnSz;
  unsigned int TotalSize;
};


struct _IMAGE_AUX_SYMBOL::__unnamed
{
  unsigned int TagIndex;
  _IMAGE_AUX_SYMBOL::__unnamed::__unnamed Misc;
  _IMAGE_AUX_SYMBOL::__unnamed::__unnamed FcnAry;
  __declspec(align(8)) unsigned __int16 TvIndex;
};


union _IMAGE_AUX_SYMBOL
{
  _IMAGE_AUX_SYMBOL::__unnamed Sym;
  _IMAGE_AUX_SYMBOL::__unnamed File;
  _IMAGE_AUX_SYMBOL::__unnamed Section;
};


struct _BY_HANDLE_FILE_INFORMATION
{
  unsigned int dwFileAttributes;
  _FILETIME ftCreationTime;
  _FILETIME ftLastAccessTime;
  _FILETIME ftLastWriteTime;
  unsigned int dwVolumeSerialNumber;
  unsigned int nFileSizeHigh;
  unsigned int nFileSizeLow;
  unsigned int nNumberOfLinks;
  unsigned int nFileIndexHigh;
  unsigned int nFileIndexLow;
};


struct _STARTUPINFOA
{
  unsigned int cb;
  char *lpReserved;
  char *lpDesktop;
  char *lpTitle;
  unsigned int dwX;
  unsigned int dwY;
  unsigned int dwXSize;
  unsigned int dwYSize;
  unsigned int dwXCountChars;
  unsigned int dwYCountChars;
  unsigned int dwFillAttribute;
  unsigned int dwFlags;
  unsigned __int16 wShowWindow;
  unsigned __int16 cbReserved2;
  char *lpReserved2;
  void *hStdInput;
  void *hStdOutput;
  void *hStdError;
};


struct _CRYPT_X942_OTHER_INFO
{
  char *pszContentEncryptionObjId;
  char rgbCounter[4];
  char rgbKeyLength[4];
  _CRYPTOAPI_BLOB PubInfo;
};


struct _EVENTLOGRECORD
{
  unsigned int Length;
  unsigned int Reserved;
  unsigned int RecordNumber;
  unsigned int TimeGenerated;
  unsigned int TimeWritten;
  unsigned int EventID;
  unsigned __int16 EventType;
  unsigned __int16 NumStrings;
  unsigned __int16 EventCategory;
  unsigned __int16 ReservedFlags;
  unsigned int ClosingRecordNumber;
  unsigned int StringOffset;
  unsigned int UserSidLength;
  unsigned int UserSidOffset;
  unsigned int DataLength;
  unsigned int DataOffset;
};


struct tagSTYLESTRUCT
{
  unsigned int styleOld;
  unsigned int styleNew;
};


struct _cpinfoexA
{
  unsigned int MaxCharSize;
  char DefaultChar[2];
  char LeadByte[12];
  unsigned __int16 UnicodeDefaultChar;
  unsigned int CodePage;
  char CodePageName[260];
};


struct _MINIDUMP_MEMORY_DESCRIPTOR
{
  unsigned __int64 StartOfMemoryRange;
  _MINIDUMP_LOCATION_DESCRIPTOR Memory;
};


struct HMONITOR__
{
  int unused;
};


struct tagEMRMODIFYWORLDTRANSFORM
{
  tagEMR emr;
  tagXFORM xform;
  unsigned int iMode;
};


struct tagEXTLOGFONTA
{
  tagLOGFONTA elfLogFont;
  char elfFullName[64];
  char elfStyle[32];
  unsigned int elfVersion;
  unsigned int elfStyleSize;
  unsigned int elfMatch;
  unsigned int elfReserved;
  char elfVendorId[4];
  unsigned int elfCulture;
  tagPANOSE elfPanose;
};


struct HBITMAP__
{
  int unused;
};


struct tagMENUITEMINFOA
{
  unsigned int cbSize;
  unsigned int fMask;
  unsigned int fType;
  unsigned int fState;
  unsigned int wID;
  HMENU__ *hSubMenu;
  HBITMAP__ *hbmpChecked;
  HBITMAP__ *hbmpUnchecked;
  unsigned int dwItemData;
  char *dwTypeData;
  unsigned int cch;
  HBITMAP__ *hbmpItem;
};


struct _CERT_ALT_NAME_INFO
{
  unsigned int cAltEntry;
  _CERT_ALT_NAME_ENTRY *rgAltEntry;
};


struct _IMAGE_FUNCTION_ENTRY
{
  unsigned int StartingAddress;
  unsigned int EndingAddress;
  unsigned int EndOfPrologue;
};


struct _FPO_DATA
{
  unsigned int ulOffStart;
  unsigned int cbProcSize;
  unsigned int cdwLocals;
  unsigned __int16 cdwParams;
  __int16 _bf14;
};


struct _IMAGE_COFF_SYMBOLS_HEADER
{
  unsigned int NumberOfSymbols;
  unsigned int LvaToFirstSymbol;
  unsigned int NumberOfLinenumbers;
  unsigned int LvaToFirstLinenumber;
  unsigned int RvaToFirstByteOfCode;
  unsigned int RvaToLastByteOfCode;
  unsigned int RvaToFirstByteOfData;
  unsigned int RvaToLastByteOfData;
};


struct _IMAGE_DEBUG_DIRECTORY
{
  unsigned int Characteristics;
  unsigned int TimeDateStamp;
  unsigned __int16 MajorVersion;
  unsigned __int16 MinorVersion;
  unsigned int Type;
  unsigned int SizeOfData;
  unsigned int AddressOfRawData;
  unsigned int PointerToRawData;
};


struct _IMAGE_DEBUG_INFORMATION
{
  _LIST_ENTRY List;
  unsigned int ReservedSize;
  void *ReservedMappedBase;
  unsigned __int16 ReservedMachine;
  unsigned __int16 ReservedCharacteristics;
  unsigned int ReservedCheckSum;
  unsigned int ImageBase;
  unsigned int SizeOfImage;
  unsigned int ReservedNumberOfSections;
  _IMAGE_SECTION_HEADER *ReservedSections;
  unsigned int ReservedExportedNamesSize;
  char *ReservedExportedNames;
  unsigned int ReservedNumberOfFunctionTableEntries;
  _IMAGE_FUNCTION_ENTRY *ReservedFunctionTableEntries;
  unsigned int ReservedLowestFunctionStartingAddress;
  unsigned int ReservedHighestFunctionEndingAddress;
  unsigned int ReservedNumberOfFpoTableEntries;
  _FPO_DATA *ReservedFpoTableEntries;
  unsigned int SizeOfCoffSymbols;
  _IMAGE_COFF_SYMBOLS_HEADER *CoffSymbols;
  unsigned int ReservedSizeOfCodeViewSymbols;
  void *ReservedCodeViewSymbols;
  char *ImageFilePath;
  char *ImageFileName;
  char *ReservedDebugFilePath;
  unsigned int ReservedTimeDateStamp;
  int ReservedRomImage;
  _IMAGE_DEBUG_DIRECTORY *ReservedDebugDirectory;
  unsigned int ReservedNumberOfDebugDirectories;
  unsigned int ReservedOriginalFunctionTableBaseAddress;
  unsigned int Reserved[2];
};


struct _currencyfmtW
{
  unsigned int NumDigits;
  unsigned int LeadingZero;
  unsigned int Grouping;
  unsigned __int16 *lpDecimalSep;
  unsigned __int16 *lpThousandSep;
  unsigned int NegativeOrder;
  unsigned int PositiveOrder;
  unsigned __int16 *lpCurrencySymbol;
};


struct _CERT_BASIC_CONSTRAINTS2_INFO
{
  int fCA;
  int fPathLenConstraint;
  unsigned int dwPathLenConstraint;
};


struct _ACL
{
  char AclRevision;
  char Sbz1;
  unsigned __int16 AclSize;
  unsigned __int16 AceCount;
  unsigned __int16 Sbz2;
};


struct _TOKEN_DEFAULT_DACL
{
  _ACL *DefaultDacl;
};


struct $5ACE225D4D14CE0550A9F5A217E306C5
{
  __int16 dmOrientation;
  __int16 dmPaperSize;
  __int16 dmPaperLength;
  __int16 dmPaperWidth;
};


union $CA2C2170EABAD629BBBFEDAA95C12DEB
{
  $5ACE225D4D14CE0550A9F5A217E306C5 _s0;
  _POINTL dmPosition;
};


struct $84BDF2D0EF3E6D92B6C33770B276E406
{
  __int16 dmScale;
  __int16 dmCopies;
};


union $E29B8DCD6F939C9CF7074045C83AF3EE
{
  $84BDF2D0EF3E6D92B6C33770B276E406 _s0;
  unsigned int dmDisplayOrientation;
};


struct $319163E49F0A6F35652FDFBFBA0FF503
{
  __int16 dmDefaultSource;
  __int16 dmPrintQuality;
};


union $7D362512FEF071268FC3C90790B478CC
{
  $319163E49F0A6F35652FDFBFBA0FF503 _s0;
  unsigned int dmDisplayFixedOutput;
};


union $309666D137CBB19809FA597AD348B415
{
  unsigned int dmDisplayFlags;
  unsigned int dmNup;
};


struct _devicemodeA
{
  char dmDeviceName[32];
  unsigned __int16 dmSpecVersion;
  unsigned __int16 dmDriverVersion;
  unsigned __int16 dmSize;
  unsigned __int16 dmDriverExtra;
  unsigned int dmFields;
  $CA2C2170EABAD629BBBFEDAA95C12DEB ___u6;
  $E29B8DCD6F939C9CF7074045C83AF3EE ___u7;
  $7D362512FEF071268FC3C90790B478CC ___u8;
  __int16 dmColor;
  __int16 dmDuplex;
  __int16 dmYResolution;
  __int16 dmTTOption;
  __int16 dmCollate;
  char dmFormName[32];
  unsigned __int16 dmLogPixels;
  unsigned int dmBitsPerPel;
  unsigned int dmPelsWidth;
  unsigned int dmPelsHeight;
  $309666D137CBB19809FA597AD348B415 ___u19;
  unsigned int dmDisplayFrequency;
  unsigned int dmICMMethod;
  unsigned int dmICMIntent;
  unsigned int dmMediaType;
  unsigned int dmDitherType;
  unsigned int dmReserved1;
  unsigned int dmReserved2;
  unsigned int dmPanningWidth;
  unsigned int dmPanningHeight;
};


struct tagEMRLINETO
{
  tagEMR emr;
  _POINTL ptl;
};


struct QOS_OBJECT_HDR
{
  unsigned int ObjectType;
  unsigned int ObjectLength;
};


union $18D88968084CBEE834030F63CA1057E2
{
  unsigned int Name;
  unsigned __int16 Id;
};


struct _IMAGE_RESOURCE_DIRECTORY_ENTRY
{
  $18D88968084CBEE834030F63CA1057E2 ___u0;
  unsigned int OffsetToData;
};


struct _GRADIENT_TRIANGLE
{
  unsigned int Vertex1;
  unsigned int Vertex2;
  unsigned int Vertex3;
};


struct tagEMRROUNDRECT
{
  tagEMR emr;
  _RECTL rclBox;
  tagSIZE szlCorner;
};


struct _ADMINISTRATOR_POWER_POLICY
{
  _SYSTEM_POWER_STATE MinSleep;
  _SYSTEM_POWER_STATE MaxSleep;
  unsigned int MinVideoTimeout;
  unsigned int MaxVideoTimeout;
  unsigned int MinSpindownTimeout;
  unsigned int MaxSpindownTimeout;
};


struct _ASSEMBLY_FILE_DETAILED_INFORMATION
{
  unsigned int ulFlags;
  unsigned int ulFilenameLength;
  unsigned int ulPathLength;
  const unsigned __int16 *lpFileName;
  const unsigned __int16 *lpFilePath;
};


struct _UNLOAD_DLL_DEBUG_INFO
{
  void *lpBaseOfDll;
};


struct tagLOGPEN
{
  unsigned int lopnStyle;
  tagPOINT lopnWidth;
  unsigned int lopnColor;
};


struct _REMOTE_NAME_INFOW
{
  unsigned __int16 *lpUniversalName;
  unsigned __int16 *lpConnectionName;
  unsigned __int16 *lpRemainingPath;
};


struct _CRL_FIND_ISSUED_FOR_PARA
{
  _CERT_CONTEXT *pSubjectCert;
  _CERT_CONTEXT *pIssuerCert;
};


struct _IMAGEHLP_SYMBOL_SRC
{
  unsigned int sizeofstruct;
  unsigned int type;
  char file[260];
};


struct _RIP_INFO
{
  unsigned int dwError;
  unsigned int dwType;
};


struct tagLOGBRUSH32
{
  unsigned int lbStyle;
  unsigned int lbColor;
  unsigned int lbHatch;
};


struct tagKBDLLHOOKSTRUCT
{
  unsigned int vkCode;
  unsigned int scanCode;
  unsigned int flags;
  unsigned int time;
  unsigned int dwExtraInfo;
};


struct tagLOGBRUSH
{
  unsigned int lbStyle;
  unsigned int lbColor;
  unsigned int lbHatch;
};


struct _CAT_MEMBERINFO
{
  unsigned __int16 *pwszSubjGuid;
  unsigned int dwCertVersion;
};


struct tagCOLORMATCHTOTARGET
{
  tagEMR emr;
  unsigned int dwAction;
  unsigned int dwFlags;
  unsigned int cbName;
  unsigned int cbData;
  char Data[1];
};


struct _CERT_POLICY_ID
{
  unsigned int cCertPolicyElementId;
  char **rgpszCertPolicyElementId;
};


struct _CERT_KEY_USAGE_RESTRICTION_INFO
{
  unsigned int cCertPolicyId;
  _CERT_POLICY_ID *rgCertPolicyId;
  _CRYPT_BIT_BLOB RestrictedKeyUsage;
};


struct _SPC_INDIRECT_DATA_CONTENT
{
  _CRYPT_ATTRIBUTE_TYPE_VALUE Data;
  _CRYPT_ALGORITHM_IDENTIFIER DigestAlgorithm;
  _CRYPTOAPI_BLOB Digest;
};


struct _ABC
{
  int abcA;
  unsigned int abcB;
  int abcC;
};


struct _NETINFOSTRUCT
{
  unsigned int cbStructure;
  unsigned int dwProviderVersion;
  unsigned int dwStatus;
  unsigned int dwCharacteristics;
  unsigned int dwHandle;
  unsigned __int16 wNetType;
  unsigned int dwPrinters;
  unsigned int dwDrives;
};


struct _SCHANNEL_ALG
{
  unsigned int dwUse;
  unsigned int Algid;
  unsigned int cBits;
  unsigned int dwFlags;
  unsigned int dwReserved;
};


struct _CERT_CREATE_CONTEXT_PARA
{
  unsigned int cbSize;
  void (__stdcall *pfnFree)(void *);
  void *pvFree;
};


struct _MINIDUMP_MEMORY_DESCRIPTOR64
{
  unsigned __int64 StartOfMemoryRange;
  unsigned __int64 DataSize;
};


struct _MINIDUMP_MEMORY64_LIST
{
  unsigned __int64 NumberOfMemoryRanges;
  unsigned __int64 BaseRva;
  _MINIDUMP_MEMORY_DESCRIPTOR64 MemoryRanges[];
};


struct _ACCESS_ALLOWED_CALLBACK_OBJECT_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int Flags;
  _GUID ObjectType;
  _GUID InheritedObjectType;
  unsigned int SidStart;
};


struct HKEY__
{
  int unused;
};


struct tagEMRSELECTPALETTE
{
  tagEMR emr;
  unsigned int ihPal;
};


struct _DSSSEED
{
  unsigned int counter;
  char seed[20];
};


struct _PUBKEYVER3
{
  unsigned int magic;
  unsigned int bitlenP;
  unsigned int bitlenQ;
  unsigned int bitlenJ;
  _DSSSEED DSSSeed;
};


struct _CERT_REGISTRY_STORE_ROAMING_PARA
{
  HKEY__ *hKey;
  unsigned __int16 *pwszStoreDirectory;
};


struct _CRYPT_PROVIDER_REGDEFUSAGE
{
  unsigned int cbStruct;
  _GUID *pgActionID;
  unsigned __int16 *pwszDllName;
  char *pwszLoadCallbackDataFunctionName;
  char *pwszFreeCallbackDataFunctionName;
};


struct hostent
{
  char *h_name;
  char **h_aliases;
  __int16 h_addrtype;
  __int16 h_length;
  char **h_addr_list;
};


struct tagENUMLOGFONTEXA
{
  tagLOGFONTA elfLogFont;
  char elfFullName[64];
  char elfStyle[32];
  char elfScript[32];
};


struct tagDESIGNVECTOR
{
  unsigned int dvReserved;
  unsigned int dvNumAxes;
  int dvValues[16];
};


struct tagENUMLOGFONTEXDVA
{
  tagENUMLOGFONTEXA elfEnumLogfontEx;
  tagDESIGNVECTOR elfDesignVector;
};


struct tagDRAWTEXTPARAMS
{
  unsigned int cbSize;
  int iTabLength;
  int iLeftMargin;
  int iRightMargin;
  unsigned int uiLengthDrawn;
};


struct _WSAQuerySetW
{
  unsigned int dwSize;
  unsigned __int16 *lpszServiceInstanceName;
  _GUID *lpServiceClassId;
  _WSAVersion *lpVersion;
  unsigned __int16 *lpszComment;
  unsigned int dwNameSpace;
  _GUID *lpNSProviderId;
  unsigned __int16 *lpszContext;
  unsigned int dwNumberOfProtocols;
  _AFPROTOCOLS *lpafpProtocols;
  unsigned __int16 *lpszQueryString;
  unsigned int dwNumberOfCsAddrs;
  _CSADDR_INFO *lpcsaBuffer;
  unsigned int dwOutputFlags;
  _BLOB *lpBlob;
};


struct _SECURITY_ATTRIBUTES
{
  unsigned int nLength;
  void *lpSecurityDescriptor;
  int bInheritHandle;
};


struct tagPELARRAY
{
  int paXCount;
  int paYCount;
  int paXExt;
  int paYExt;
  char paRGBs;
};


struct tagMDICREATESTRUCTA
{
  const char *szClass;
  const char *szTitle;
  void *hOwner;
  int x;
  int y;
  int cx;
  int cy;
  unsigned int style;
  int lParam;
};


struct tagSTYLEBUFW
{
  unsigned int dwStyle;
  unsigned __int16 szDescription[32];
};


struct _WSANSClassInfoA
{
  char *lpszName;
  unsigned int dwNameSpace;
  unsigned int dwValueType;
  unsigned int dwValueSize;
  void *lpValue;
};


struct _POINTFLOAT
{
  float x;
  float y;
};


struct _GLYPHMETRICSFLOAT
{
  float gmfBlackBoxX;
  float gmfBlackBoxY;
  _POINTFLOAT gmfptGlyphOrigin;
  float gmfCellIncX;
  float gmfCellIncY;
};


union $598610CC988E402B9A82B84B75BDDF21
{
  unsigned int dwValue;
  unsigned int Algid;
  unsigned int dwLength;
};


struct _CRYPT_OID_INFO
{
  unsigned int cbSize;
  const char *pszOID;
  const unsigned __int16 *pwszName;
  unsigned int dwGroupId;
  $598610CC988E402B9A82B84B75BDDF21 ___u4;
  _CRYPTOAPI_BLOB ExtraInfo;
};


struct _CRYPT_ASYNC_RETRIEVAL_COMPLETION
{
  void (__stdcall *pfnCompletion)(void *, unsigned int, const char *, char *, void *);
  void *pvCompletion;
};


struct _KDHELP
{
  unsigned int Thread;
  unsigned int ThCallbackStack;
  unsigned int NextCallback;
  unsigned int FramePointer;
  unsigned int KiCallUserMode;
  unsigned int KeUserCallbackDispatcher;
  unsigned int SystemRangeStart;
  unsigned int ThCallbackBStore;
  unsigned int Reserved[8];
};


struct _SYSTEM_ALARM_CALLBACK_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int SidStart;
};


struct tagFONTSIGNATURE
{
  unsigned int fsUsb[4];
  unsigned int fsCsb[2];
};


struct POWER_ACTION_POLICY
{
  POWER_ACTION Action;
  unsigned int Flags;
  unsigned int EventCode;
};


struct SYSTEM_POWER_LEVEL
{
  char Enable;
  char Spare[3];
  unsigned int BatteryLevel;
  POWER_ACTION_POLICY PowerPolicy;
  _SYSTEM_POWER_STATE MinSystemState;
};


struct _IMAGE_OS2_HEADER
{
  unsigned __int16 ne_magic;
  char ne_ver;
  char ne_rev;
  unsigned __int16 ne_enttab;
  unsigned __int16 ne_cbenttab;
  int ne_crc;
  unsigned __int16 ne_flags;
  unsigned __int16 ne_autodata;
  unsigned __int16 ne_heap;
  unsigned __int16 ne_stack;
  int ne_csip;
  int ne_sssp;
  unsigned __int16 ne_cseg;
  unsigned __int16 ne_cmod;
  unsigned __int16 ne_cbnrestab;
  unsigned __int16 ne_segtab;
  unsigned __int16 ne_rsrctab;
  unsigned __int16 ne_restab;
  unsigned __int16 ne_modtab;
  unsigned __int16 ne_imptab;
  int ne_nrestab;
  unsigned __int16 ne_cmovent;
  unsigned __int16 ne_align;
  unsigned __int16 ne_cres;
  char ne_exetyp;
  char ne_flagsothers;
  unsigned __int16 ne_pretthunks;
  unsigned __int16 ne_psegrefbytes;
  unsigned __int16 ne_swaparea;
  unsigned __int16 ne_expver;
};


struct _MESSAGE_RESOURCE_BLOCK
{
  unsigned int LowId;
  unsigned int HighId;
  unsigned int OffsetToEntries;
};


struct tagACTCTXA
{
  unsigned int cbSize;
  unsigned int dwFlags;
  const char *lpSource;
  unsigned __int16 wProcessorArchitecture;
  unsigned __int16 wLangId;
  const char *lpAssemblyDirectory;
  const char *lpResourceName;
  const char *lpApplicationName;
  HINSTANCE__ *hModule;
};


struct _WSANAMESPACE_INFOA
{
  _GUID NSProviderId;
  unsigned int dwNameSpace;
  int fActive;
  unsigned int dwVersion;
  char *lpszIdentifier;
};


struct tagEMRSETDIBITSTODEVICE
{
  tagEMR emr;
  _RECTL rclBounds;
  int xDest;
  int yDest;
  int xSrc;
  int ySrc;
  int cxSrc;
  int cySrc;
  unsigned int offBmiSrc;
  unsigned int cbBmiSrc;
  unsigned int offBitsSrc;
  unsigned int cbBitsSrc;
  unsigned int iUsageSrc;
  unsigned int iStartScan;
  unsigned int cScans;
};


struct $409DFF2A380C4FFE2B587D0390AC124E
{
  unsigned __int16 wProcessorArchitecture;
  unsigned __int16 wReserved;
};


union $4E425D15FA46D3275A5884F16CC19A55
{
  unsigned int dwOemId;
  $409DFF2A380C4FFE2B587D0390AC124E _s1;
};


struct _SYSTEM_INFO
{
  $4E425D15FA46D3275A5884F16CC19A55 ___u0;
  unsigned int dwPageSize;
  void *lpMinimumApplicationAddress;
  void *lpMaximumApplicationAddress;
  unsigned int dwActiveProcessorMask;
  unsigned int dwNumberOfProcessors;
  unsigned int dwProcessorType;
  unsigned int dwAllocationGranularity;
  unsigned __int16 wProcessorLevel;
  unsigned __int16 wProcessorRevision;
};


struct tagACTCTXW
{
  unsigned int cbSize;
  unsigned int dwFlags;
  const unsigned __int16 *lpSource;
  unsigned __int16 wProcessorArchitecture;
  unsigned __int16 wLangId;
  const unsigned __int16 *lpAssemblyDirectory;
  const unsigned __int16 *lpResourceName;
  const unsigned __int16 *lpApplicationName;
  HINSTANCE__ *hModule;
};


struct exception
{
  exceptionVtbl *vfptr;
  const char *_m_what;
  int _m_doFree;
};


struct exceptionVtbl
{
  void *(__thiscall *__vecDelDtor)(exception *this, unsigned int);
  const char *(__thiscall *what)(exception *this);
};


struct std::logic_error
{
  exception baseclass_0;
  std::basic_string<char,std::char_traits<char>,std::allocator<char> > _Str;
};


struct std::length_error
{
  std::logic_error baseclass_0;
};


struct std::runtime_error
{
  exception baseclass_0;
  std::basic_string<char,std::char_traits<char>,std::allocator<char> > _Str;
};


struct std::locale::facet
{
  std::locale::facetVtbl *vfptr;
  unsigned int _Refs;
};


struct std::locale::facetVtbl
{
  void *(__thiscall *__vecDelDtor)(std::locale::facet *this, unsigned int);
};


struct std::ctype_base
{
  std::locale::facet baseclass_0;
};


struct _Ctypevec
{
  unsigned int _Hand;
  unsigned int _Page;
  const __int16 *_Table;
  int _Delfl;
};


struct std::ctype<char>
{
  std::ctype_base baseclass_0;
  _Ctypevec _Ctype;
};


struct std::locale::id
{
  unsigned int _Id;
};


struct std::_Lockit
{
  int _Locktype;
};


struct std::_Locinfo
{
  std::_Lockit _Lock;
  std::basic_string<char,std::char_traits<char>,std::allocator<char> > _Days;
  std::basic_string<char,std::char_traits<char>,std::allocator<char> > _Months;
  std::basic_string<char,std::char_traits<char>,std::allocator<char> > _Oldlocname;
  std::basic_string<char,std::char_traits<char>,std::allocator<char> > _Newlocname;
};


struct std::allocator<void>
{
  char dummy[1];
};


struct std::_Init_locks
{
  char dummy[1];
};


struct std::_Iosb<int>
{
  char dummy[1];
};


struct std::ios_base
{
  std::ios_baseVtbl *vfptr;
  $236B402BA31FF6156C65B06A3429EE4F ___u1;
  int _Mystate;
  int _Except;
  int _Fmtfl;
  int _Prec;
  int _Wide;
  std::ios_base::_Iosarray *_Arr;
  std::ios_base::_Fnarray *_Calls;
  std::locale *_Ploc;
};


struct std::ios_baseVtbl
{
  void *(__thiscall *__vecDelDtor)(std::ios_base *this, unsigned int);
};


struct std::ios_base::_Iosarray
{
  std::ios_base::_Iosarray *_Next;
  int _Index;
  int _Lo;
  void *_Vp;
};


struct std::ios_base::_Fnarray
{
  std::ios_base::_Fnarray *_Next;
  int _Index;
  void (__cdecl *_Pfn)(std::ios_base::event, std::ios_base *, int);
};


struct std::_Locbase<int>
{
  char dummy[1];
};


struct std::locale::_Locimp
{
  std::locale::facet baseclass_0;
  std::locale::facet **_Facetvec;
  unsigned int _Facetcount;
  int _Catmask;
  bool _Xparent;
  std::basic_string<char,std::char_traits<char>,std::allocator<char> > _Name;
};


union $DDABA67CADCE249E58A6AD9913479623
{
  std::_Locbase<int> baseclass_0;
  std::locale::_Locimp *_Ptr;
};


struct std::locale
{
  $DDABA67CADCE249E58A6AD9913479623 ___u0;
};


union $236B402BA31FF6156C65B06A3429EE4F
{
  std::_Iosb<int> baseclass_4;
  unsigned int _Stdstr;
};


struct std::basic_streambuf<unsigned short,std::char_traits<unsigned short> >
{
  std::basic_streambuf<unsigned short,std::char_traits<unsigned short> >Vtbl *vfptr;
  std::_Mutex _Mylock;
  unsigned __int16 *_Gfirst;
  unsigned __int16 *_Pfirst;
  unsigned __int16 **_IGfirst;
  unsigned __int16 **_IPfirst;
  unsigned __int16 *_Gnext;
  unsigned __int16 *_Pnext;
  unsigned __int16 **_IGnext;
  unsigned __int16 **_IPnext;
  int _Gcount;
  int _Pcount;
  int *_IGcount;
  int *_IPcount;
  std::locale *_Plocale;
};


struct std::fpos<int>
{
  int _Myoff;
  __int64 _Fpos;
  int _Mystate;
};


struct std::basic_streambuf<unsigned short,std::char_traits<unsigned short> >Vtbl
{
  void *(__thiscall *__vecDelDtor)(std::basic_streambuf<unsigned short,std::char_traits<unsigned short> > *this, unsigned int);
  unsigned __int16 (__thiscall *overflow)(std::basic_streambuf<unsigned short,std::char_traits<unsigned short> > *this, unsigned __int16);
  unsigned __int16 (__thiscall *pbackfail)(std::basic_streambuf<unsigned short,std::char_traits<unsigned short> > *this, unsigned __int16);
  int (__thiscall *showmanyc)(std::basic_streambuf<unsigned short,std::char_traits<unsigned short> > *this);
  unsigned __int16 (__thiscall *underflow)(std::basic_streambuf<unsigned short,std::char_traits<unsigned short> > *this);
  unsigned __int16 (__thiscall *uflow)(std::basic_streambuf<unsigned short,std::char_traits<unsigned short> > *this);
  int (__thiscall *xsgetn)(std::basic_streambuf<unsigned short,std::char_traits<unsigned short> > *this, unsigned __int16 *, int);
  int (__thiscall *xsputn)(std::basic_streambuf<unsigned short,std::char_traits<unsigned short> > *this, const unsigned __int16 *, int);
  std::fpos<int> *(__thiscall *seekoff)(std::basic_streambuf<unsigned short,std::char_traits<unsigned short> > *this, std::fpos<int> *result, int, int, int);
  std::fpos<int> *(__thiscall *seekpos)(std::basic_streambuf<unsigned short,std::char_traits<unsigned short> > *this, std::fpos<int> *result, std::fpos<int>, int);
  std::basic_streambuf<unsigned short,std::char_traits<unsigned short> > *(__thiscall *setbuf)(std::basic_streambuf<unsigned short,std::char_traits<unsigned short> > *this, unsigned __int16 *, int);
  int (__thiscall *sync)(std::basic_streambuf<unsigned short,std::char_traits<unsigned short> > *this);
  void (__thiscall *imbue)(std::basic_streambuf<unsigned short,std::char_traits<unsigned short> > *this, std::locale *);
};


struct std::_Mutex
{
  void *_Mtx;
};


struct std::basic_ostream<unsigned short,std::char_traits<unsigned short> >
{
  char dummy[56];
};


struct std::basic_ios<unsigned short,std::char_traits<unsigned short> >
{
  std::ios_base baseclass_0;
  std::basic_streambuf<unsigned short,std::char_traits<unsigned short> > *_Mystrbuf;
  std::basic_ostream<unsigned short,std::char_traits<unsigned short> > *_Tiestr;
  unsigned __int16 _Fillch;
};


struct std::basic_istream<unsigned short,std::char_traits<unsigned short> >
{
  _BYTE gap0[4];
  int _Chcount;
  _BYTE gap8[52];
};


struct _Cvtvec
{
  unsigned int _Hand;
  unsigned int _Page;
};


struct std::ctype<unsigned short>
{
  std::ctype_base baseclass_0;
  _Ctypevec _Ctype;
  _Cvtvec _Cvt;
};


struct std::basic_istream<unsigned short,std::char_traits<unsigned short> >::_Sentry_base
{
  std::basic_istream<unsigned short,std::char_traits<unsigned short> > *_Myistr;
};


struct std::basic_istream<unsigned short,std::char_traits<unsigned short> >::sentry
{
  std::basic_istream<unsigned short,std::char_traits<unsigned short> >::_Sentry_base baseclass_0;
  bool _Ok;
};


struct std::basic_streambuf<char,std::char_traits<char> >
{
  std::basic_streambuf<char,std::char_traits<char> >Vtbl *vfptr;
  std::_Mutex _Mylock;
  char *_Gfirst;
  char *_Pfirst;
  char **_IGfirst;
  char **_IPfirst;
  char *_Gnext;
  char *_Pnext;
  char **_IGnext;
  char **_IPnext;
  int _Gcount;
  int _Pcount;
  int *_IGcount;
  int *_IPcount;
  std::locale *_Plocale;
};


struct std::basic_streambuf<char,std::char_traits<char> >Vtbl
{
  void *(__thiscall *__vecDelDtor)(std::basic_streambuf<char,std::char_traits<char> > *this, unsigned int);
  int (__thiscall *overflow)(std::basic_streambuf<char,std::char_traits<char> > *this, int);
  int (__thiscall *pbackfail)(std::basic_streambuf<char,std::char_traits<char> > *this, int);
  int (__thiscall *showmanyc)(std::basic_streambuf<char,std::char_traits<char> > *this);
  int (__thiscall *underflow)(std::basic_streambuf<char,std::char_traits<char> > *this);
  int (__thiscall *uflow)(std::basic_streambuf<char,std::char_traits<char> > *this);
  int (__thiscall *xsgetn)(std::basic_streambuf<char,std::char_traits<char> > *this, char *, int);
  int (__thiscall *xsputn)(std::basic_streambuf<char,std::char_traits<char> > *this, const char *, int);
  std::fpos<int> *(__thiscall *seekoff)(std::basic_streambuf<char,std::char_traits<char> > *this, std::fpos<int> *result, int, int, int);
  std::fpos<int> *(__thiscall *seekpos)(std::basic_streambuf<char,std::char_traits<char> > *this, std::fpos<int> *result, std::fpos<int>, int);
  std::basic_streambuf<char,std::char_traits<char> > *(__thiscall *setbuf)(std::basic_streambuf<char,std::char_traits<char> > *this, char *, int);
  int (__thiscall *sync)(std::basic_streambuf<char,std::char_traits<char> > *this);
  void (__thiscall *imbue)(std::basic_streambuf<char,std::char_traits<char> > *this, std::locale *);
};


struct std::basic_ostream<char,std::char_traits<char> >
{
  char dummy[56];
};


struct std::basic_ios<char,std::char_traits<char> >
{
  std::ios_base baseclass_0;
  std::basic_streambuf<char,std::char_traits<char> > *_Mystrbuf;
  std::basic_ostream<char,std::char_traits<char> > *_Tiestr;
  char _Fillch;
};


struct std::_Int_iterator_tag
{
  char dummy[1];
};


struct std::iterator_traits<unsigned short>
{
  char dummy[1];
};


struct std::basic_ostream<char,std::char_traits<char> >::_Sentry_base
{
  std::basic_ostream<char,std::char_traits<char> > *_Myostr;
};


struct std::basic_ostream<char,std::char_traits<char> >::sentry
{
  std::basic_ostream<char,std::char_traits<char> >::_Sentry_base baseclass_0;
  bool _Ok;
};


struct std::bad_cast
{
  std::exception baseclass_0;
};


struct std::output_iterator_tag
{
  char dummy[1];
};


struct std::invalid_argument
{
  std::logic_error baseclass_0;
};


struct std::iterator<std::output_iterator_tag,void,void,void,void>
{
  char dummy[1];
};


struct std::_Outit
{
  std::iterator<std::output_iterator_tag,void,void,void,void> baseclass_0;
};


struct std::codecvt_base
{
  std::locale::facet baseclass_0;
};


struct std::iterator_traits<unsigned long>
{
  char dummy[1];
};


struct std::underflow_error
{
  std::runtime_error baseclass_0;
};


struct std::bad_exception
{
  exception baseclass_0;
};


struct std::basic_istream<char,std::char_traits<char> >
{
  _BYTE gap0[4];
  int _Chcount;
  _BYTE gap8[52];
};


struct std::basic_istream<char,std::char_traits<char> >::_Sentry_base
{
  std::basic_istream<char,std::char_traits<char> > *_Myistr;
};


struct std::basic_istream<char,std::char_traits<char> >::sentry
{
  std::basic_istream<char,std::char_traits<char> >::_Sentry_base baseclass_0;
  bool _Ok;
};


struct std::random_access_iterator_tag
{
  std::bidirectional_iterator_tag baseclass_0;
};


struct std::iterator_traits<short>
{
  char dummy[1];
};


struct std::bad_typeid
{
  std::exception baseclass_0;
};


struct std::codecvt<unsigned short,char,int>
{
  std::codecvt_base baseclass_0;
  _Cvtvec _Cvt;
};


struct std::iterator_traits<unsigned __int64>
{
  char dummy[1];
};


struct std::iterator_traits<signed char>
{
  char dummy[1];
};


struct std::_Facetptr<std::ctype<char> >
{
  char dummy[1];
};


struct std::char_traits<unsigned short>
{
  char dummy[1];
};


struct std::iterator_traits<__int64>
{
  char dummy[1];
};


struct std::domain_error
{
  std::logic_error baseclass_0;
};


struct std::__non_rtti_object
{
  std::bad_typeid baseclass_0;
};


struct std::overflow_error
{
  std::runtime_error baseclass_0;
};


struct std::iterator_traits<unsigned int>
{
  char dummy[1];
};


struct std::range_error
{
  std::runtime_error baseclass_0;
};


struct std::iterator_traits<char>
{
  char dummy[1];
};


struct _Collvec
{
  unsigned int _Hand;
  unsigned int _Page;
};


struct std::_Timevec
{
  void *_Timeptr;
};


struct lconv
{
  char *decimal_point;
  char *thousands_sep;
  char *grouping;
  char *int_curr_symbol;
  char *currency_symbol;
  char *mon_decimal_point;
  char *mon_thousands_sep;
  char *mon_grouping;
  char *positive_sign;
  char *negative_sign;
  char int_frac_digits;
  char frac_digits;
  char p_cs_precedes;
  char p_sep_by_space;
  char n_cs_precedes;
  char n_sep_by_space;
  char p_sign_posn;
  char n_sign_posn;
};


struct std::out_of_range
{
  std::logic_error baseclass_0;
};


struct std::basic_ostream<unsigned short,std::char_traits<unsigned short> >::_Sentry_base
{
  std::basic_ostream<unsigned short,std::char_traits<unsigned short> > *_Myostr;
};


struct std::basic_ostream<unsigned short,std::char_traits<unsigned short> >::sentry
{
  std::basic_ostream<unsigned short,std::char_traits<unsigned short> >::_Sentry_base baseclass_0;
  bool _Ok;
};


struct std::nothrow_t
{
  char dummy[1];
};


struct std::iterator_traits<unsigned char>
{
  char dummy[1];
};


struct std::iterator_traits<int>
{
  char dummy[1];
};


struct std::iterator_traits<bool>
{
  char dummy[1];
};


struct std::iterator_traits<long>
{
  char dummy[1];
};


struct std::bad_alloc
{
  exception baseclass_0;
};


struct std::_Nonscalar_ptr_iterator_tag
{
  char dummy[1];
};


struct std::ios_base::failure
{
  std::runtime_error baseclass_0;
};


struct std::ios_base::Init
{
  char dummy[1];
};


struct std::_Facetptr<std::ctype<unsigned short> >
{
  char dummy[1];
};


struct std::_Scalar_ptr_iterator_tag
{
  char dummy[1];
};


struct _ACCESS_ALLOWED_OBJECT_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int Flags;
  _GUID ObjectType;
  _GUID InheritedObjectType;
  unsigned int SidStart;
};


struct sockaddr_storage
{
  __int16 ss_family;
  char __ss_pad1[6];
  __int64 __ss_align;
  char __ss_pad2[112];
};


struct _CERT_RDN_ATTR
{
  char *pszObjId;
  unsigned int dwValueType;
  _CRYPTOAPI_BLOB Value;
};


struct _CERT_RDN
{
  unsigned int cRDNAttr;
  _CERT_RDN_ATTR *rgRDNAttr;
};


struct _CERT_STORE_PROV_INFO
{
  unsigned int cbSize;
  unsigned int cStoreProvFunc;
  void **rgpvStoreProvFunc;
  void *hStoreProv;
  unsigned int dwStoreProvFlags;
  void *hStoreProvFuncAddr2;
};


struct LIST_ENTRY32
{
  unsigned int Flink;
  unsigned int Blink;
};


union $E0927F6BE2F1645595F211B37EFD8766
{
  unsigned __int64 EndOfPrologue;
  unsigned __int64 UnwindInfoAddress;
};


struct _IMAGE_FUNCTION_ENTRY64
{
  unsigned __int64 StartingAddress;
  unsigned __int64 EndingAddress;
  $E0927F6BE2F1645595F211B37EFD8766 ___u2;
};


struct _EXIT_THREAD_DEBUG_INFO
{
  unsigned int dwExitCode;
};


struct _SERVICE_STATUS_PROCESS
{
  unsigned int dwServiceType;
  unsigned int dwCurrentState;
  unsigned int dwControlsAccepted;
  unsigned int dwWin32ExitCode;
  unsigned int dwServiceSpecificExitCode;
  unsigned int dwCheckPoint;
  unsigned int dwWaitHint;
  unsigned int dwProcessId;
  unsigned int dwServiceFlags;
};


struct _ENUM_SERVICE_STATUS_PROCESSA
{
  char *lpServiceName;
  char *lpDisplayName;
  _SERVICE_STATUS_PROCESS ServiceStatusProcess;
};


struct servent
{
  char *s_name;
  char **s_aliases;
  __int16 s_port;
  char *s_proto;
};


struct tagACCEL
{
  char fVirt;
  unsigned __int16 key;
  unsigned __int16 cmd;
};


struct _CMC_PEND_INFO
{
  _CRYPTOAPI_BLOB PendToken;
  _FILETIME PendTime;
};


union $F794C469C479E8E8200F151C136829B2
{
  unsigned int dwFailInfo;
  _CMC_PEND_INFO *pPendInfo;
};


struct _CMC_STATUS_INFO
{
  unsigned int dwStatus;
  unsigned int cBodyList;
  unsigned int *rgdwBodyList;
  unsigned __int16 *pwszStatusString;
  unsigned int dwOtherInfoChoice;
  $F794C469C479E8E8200F151C136829B2 ___u5;
};


struct _QUOTA_LIMITS
{
  unsigned int PagedPoolLimit;
  unsigned int NonPagedPoolLimit;
  unsigned int MinimumWorkingSetSize;
  unsigned int MaximumWorkingSetSize;
  unsigned int PagefileLimit;
  _LARGE_INTEGER TimeLimit;
};


struct tagSERIALKEYSW
{
  unsigned int cbSize;
  unsigned int dwFlags;
  unsigned __int16 *lpszActivePort;
  unsigned __int16 *lpszPort;
  unsigned int iBaudRate;
  unsigned int iPortState;
  unsigned int iActive;
};


struct _NETCONNECTINFOSTRUCT
{
  unsigned int cbStructure;
  unsigned int dwFlags;
  unsigned int dwSpeed;
  unsigned int dwDelay;
  unsigned int dwOptDataSize;
};


struct _CMS_DH_KEY_INFO
{
  unsigned int dwVersion;
  unsigned int Algid;
  char *pszContentEncObjId;
  _CRYPTOAPI_BLOB PubInfo;
  void *pReserved;
};


struct _IMAGE_SYMBOL::__unnamed::__unnamed
{
  unsigned int Short;
  unsigned int Long;
};


union _IMAGE_SYMBOL::__unnamed
{
  char ShortName[8];
  _IMAGE_SYMBOL::__unnamed::__unnamed Name;
  unsigned int LongName[2];
};


struct _IMAGE_SYMBOL
{
  _IMAGE_SYMBOL::__unnamed N;
  unsigned int Value;
  __int16 SectionNumber;
  unsigned __int16 Type;
  char StorageClass;
  char NumberOfAuxSymbols;
};


struct _ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION
{
  unsigned int ulFlags;
  unsigned int ulEncodedAssemblyIdentityLength;
  unsigned int ulManifestPathType;
  unsigned int ulManifestPathLength;
  _LARGE_INTEGER liManifestLastWriteTime;
  unsigned int ulPolicyPathType;
  unsigned int ulPolicyPathLength;
  _LARGE_INTEGER liPolicyLastWriteTime;
  unsigned int ulMetadataSatelliteRosterIndex;
  unsigned int ulManifestVersionMajor;
  unsigned int ulManifestVersionMinor;
  unsigned int ulPolicyVersionMajor;
  unsigned int ulPolicyVersionMinor;
  unsigned int ulAssemblyDirectoryNameLength;
  const unsigned __int16 *lpAssemblyEncodedAssemblyIdentity;
  const unsigned __int16 *lpAssemblyManifestPath;
  const unsigned __int16 *lpAssemblyPolicyPath;
  const unsigned __int16 *lpAssemblyDirectoryName;
  unsigned int ulFileCount;
};


struct tagDROPSTRUCT
{
  HWND__ *hwndSource;
  HWND__ *hwndSink;
  unsigned int wFmt;
  unsigned int dwData;
  tagPOINT ptDrop;
  unsigned int dwControlData;
};


struct _TOKEN_GROUPS_AND_PRIVILEGES
{
  unsigned int SidCount;
  unsigned int SidLength;
  _SID_AND_ATTRIBUTES *Sids;
  unsigned int RestrictedSidCount;
  unsigned int RestrictedSidLength;
  _SID_AND_ATTRIBUTES *RestrictedSids;
  unsigned int PrivilegeCount;
  unsigned int PrivilegeLength;
  _LUID_AND_ATTRIBUTES *Privileges;
  _LUID AuthenticationId;
};


struct tagMSLLHOOKSTRUCT
{
  tagPOINT pt;
  unsigned int mouseData;
  unsigned int flags;
  unsigned int time;
  unsigned int dwExtraInfo;
};


struct tagIMEMENUITEMINFOA
{
  unsigned int cbSize;
  unsigned int fType;
  unsigned int fState;
  unsigned int wID;
  HBITMAP__ *hbmpChecked;
  HBITMAP__ *hbmpUnchecked;
  unsigned int dwItemData;
  char szString[80];
  HBITMAP__ *hbmpItem;
};


struct tagEXTLOGPEN
{
  unsigned int elpPenStyle;
  unsigned int elpWidth;
  unsigned int elpBrushStyle;
  unsigned int elpColor;
  unsigned int elpHatch;
  unsigned int elpNumEntries;
  unsigned int elpStyleEntry[1];
};


struct _OUTLINETEXTMETRICA
{
  unsigned int otmSize;
  tagTEXTMETRICA otmTextMetrics;
  char otmFiller;
  tagPANOSE otmPanoseNumber;
  unsigned int otmfsSelection;
  unsigned int otmfsType;
  int otmsCharSlopeRise;
  int otmsCharSlopeRun;
  int otmItalicAngle;
  unsigned int otmEMSquare;
  int otmAscent;
  int otmDescent;
  unsigned int otmLineGap;
  unsigned int otmsCapEmHeight;
  unsigned int otmsXHeight;
  tagRECT otmrcFontBox;
  int otmMacAscent;
  int otmMacDescent;
  unsigned int otmMacLineGap;
  unsigned int otmusMinimumPPEM;
  tagPOINT otmptSubscriptSize;
  tagPOINT otmptSubscriptOffset;
  tagPOINT otmptSuperscriptSize;
  tagPOINT otmptSuperscriptOffset;
  unsigned int otmsStrikeoutSize;
  int otmsStrikeoutPosition;
  int otmsUnderscoreSize;
  int otmsUnderscorePosition;
  char *otmpFamilyName;
  char *otmpFaceName;
  char *otmpStyleName;
  char *otmpFullName;
};


struct _CRYPT_RC2_CBC_PARAMETERS
{
  unsigned int dwVersion;
  int fIV;
  char rgbIV[8];
};


struct _RASTERIZER_STATUS
{
  __int16 nSize;
  __int16 wFlags;
  __int16 nLanguageID;
};


struct _WIN32_FIND_DATAW
{
  unsigned int dwFileAttributes;
  _FILETIME ftCreationTime;
  _FILETIME ftLastAccessTime;
  _FILETIME ftLastWriteTime;
  unsigned int nFileSizeHigh;
  unsigned int nFileSizeLow;
  unsigned int dwReserved0;
  unsigned int dwReserved1;
  unsigned __int16 cFileName[260];
  unsigned __int16 cAlternateFileName[14];
};


struct _CERT_FORTEZZA_DATA_PROP
{
  char SerialNumber[8];
  int CertIndex;
  char CertLabel[36];
};


struct _CMSG_CTRL_DEL_SIGNER_UNAUTH_ATTR_PARA
{
  unsigned int cbSize;
  unsigned int dwSignerIndex;
  unsigned int dwUnauthAttrIndex;
};


struct _TOKEN_AUDIT_POLICY_ELEMENT
{
  unsigned int Category;
  unsigned int PolicyMask;
};


struct tagEMRTEXT
{
  _POINTL ptlReference;
  unsigned int nChars;
  unsigned int offString;
  unsigned int fOptions;
  _RECTL rcl;
  unsigned int offDx;
};


struct tagEMRPOLYTEXTOUTA
{
  tagEMR emr;
  _RECTL rclBounds;
  unsigned int iGraphicsMode;
  float exScale;
  float eyScale;
  int cStrings;
  tagEMRTEXT aemrtext[1];
};


struct _WIN32_FIND_DATAA
{
  unsigned int dwFileAttributes;
  _FILETIME ftCreationTime;
  _FILETIME ftLastAccessTime;
  _FILETIME ftLastWriteTime;
  unsigned int nFileSizeHigh;
  unsigned int nFileSizeLow;
  unsigned int dwReserved0;
  unsigned int dwReserved1;
  char cFileName[260];
  char cAlternateFileName[14];
};


struct tagBITMAPINFOHEADER
{
  unsigned int biSize;
  int biWidth;
  int biHeight;
  unsigned __int16 biPlanes;
  unsigned __int16 biBitCount;
  unsigned int biCompression;
  unsigned int biSizeImage;
  int biXPelsPerMeter;
  int biYPelsPerMeter;
  unsigned int biClrUsed;
  unsigned int biClrImportant;
};


struct tagNEWTEXTMETRICA
{
  int tmHeight;
  int tmAscent;
  int tmDescent;
  int tmInternalLeading;
  int tmExternalLeading;
  int tmAveCharWidth;
  int tmMaxCharWidth;
  int tmWeight;
  int tmOverhang;
  int tmDigitizedAspectX;
  int tmDigitizedAspectY;
  char tmFirstChar;
  char tmLastChar;
  char tmDefaultChar;
  char tmBreakChar;
  char tmItalic;
  char tmUnderlined;
  char tmStruckOut;
  char tmPitchAndFamily;
  char tmCharSet;
  unsigned int ntmFlags;
  unsigned int ntmSizeEM;
  unsigned int ntmCellHeight;
  unsigned int ntmAvgWidth;
};


struct tagNEWTEXTMETRICEXA
{
  tagNEWTEXTMETRICA ntmTm;
  tagFONTSIGNATURE ntmFontSig;
};


struct tagAXISINFOA
{
  int axMinValue;
  int axMaxValue;
  char axAxisName[16];
};


struct tagAXESLISTA
{
  unsigned int axlReserved;
  unsigned int axlNumAxes;
  tagAXISINFOA axlAxisInfo[16];
};


struct tagENUMTEXTMETRICA
{
  tagNEWTEXTMETRICEXA etmNewTextMetricEx;
  tagAXESLISTA etmAxesList;
};


struct _tagADDRESS
{
  unsigned int Offset;
  unsigned __int16 Segment;
  ADDRESS_MODE Mode;
};


struct _tagSTACKFRAME
{
  _tagADDRESS AddrPC;
  _tagADDRESS AddrReturn;
  _tagADDRESS AddrFrame;
  _tagADDRESS AddrStack;
  void *FuncTableEntry;
  unsigned int Params[4];
  int Far;
  int Virtual;
  unsigned int Reserved[3];
  _KDHELP KdHelp;
  _tagADDRESS AddrBStore;
};


struct tagEMRSTRETCHDIBITS
{
  tagEMR emr;
  _RECTL rclBounds;
  int xDest;
  int yDest;
  int xSrc;
  int ySrc;
  int cxSrc;
  int cySrc;
  unsigned int offBmiSrc;
  unsigned int cbBmiSrc;
  unsigned int offBitsSrc;
  unsigned int cbBitsSrc;
  unsigned int iUsageSrc;
  unsigned int dwRop;
  int cxDest;
  int cyDest;
};


struct IMAGE_LOAD_CONFIG_DIRECTORY32
{
  unsigned int Size;
  unsigned int TimeDateStamp;
  unsigned __int16 MajorVersion;
  unsigned __int16 MinorVersion;
  unsigned int GlobalFlagsClear;
  unsigned int GlobalFlagsSet;
  unsigned int CriticalSectionDefaultTimeout;
  unsigned int DeCommitFreeBlockThreshold;
  unsigned int DeCommitTotalFreeThreshold;
  unsigned int LockPrefixTable;
  unsigned int MaximumAllocationSize;
  unsigned int VirtualMemoryThreshold;
  unsigned int ProcessHeapFlags;
  unsigned int ProcessAffinityMask;
  unsigned __int16 CSDVersion;
  unsigned __int16 Reserved1;
  unsigned int EditList;
  unsigned int SecurityCookie;
  unsigned int SEHandlerTable;
  unsigned int SEHandlerCount;
};


struct _TRIVERTEX
{
  int x;
  int y;
  unsigned __int16 Red;
  unsigned __int16 Green;
  unsigned __int16 Blue;
  unsigned __int16 Alpha;
};


struct _WIN_CERTIFICATE
{
  unsigned int dwLength;
  unsigned __int16 wRevision;
  unsigned __int16 wCertificateType;
  char bCertificate[1];
};


struct _WIN_SPUB_TRUSTED_PUBLISHER_DATA
{
  void *hClientToken;
  _WIN_CERTIFICATE *lpCertificate;
};


struct _ACCESS_DENIED_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int SidStart;
};


struct _MEMORY_BASIC_INFORMATION
{
  void *BaseAddress;
  void *AllocationBase;
  unsigned int AllocationProtect;
  unsigned int RegionSize;
  unsigned int State;
  unsigned int Protect;
  unsigned int Type;
};


struct tagTEXTMETRICW
{
  int tmHeight;
  int tmAscent;
  int tmDescent;
  int tmInternalLeading;
  int tmExternalLeading;
  int tmAveCharWidth;
  int tmMaxCharWidth;
  int tmWeight;
  int tmOverhang;
  int tmDigitizedAspectX;
  int tmDigitizedAspectY;
  unsigned __int16 tmFirstChar;
  unsigned __int16 tmLastChar;
  unsigned __int16 tmDefaultChar;
  unsigned __int16 tmBreakChar;
  char tmItalic;
  char tmUnderlined;
  char tmStruckOut;
  char tmPitchAndFamily;
  char tmCharSet;
};


struct _OUTLINETEXTMETRICW
{
  unsigned int otmSize;
  tagTEXTMETRICW otmTextMetrics;
  char otmFiller;
  tagPANOSE otmPanoseNumber;
  unsigned int otmfsSelection;
  unsigned int otmfsType;
  int otmsCharSlopeRise;
  int otmsCharSlopeRun;
  int otmItalicAngle;
  unsigned int otmEMSquare;
  int otmAscent;
  int otmDescent;
  unsigned int otmLineGap;
  unsigned int otmsCapEmHeight;
  unsigned int otmsXHeight;
  tagRECT otmrcFontBox;
  int otmMacAscent;
  int otmMacDescent;
  unsigned int otmMacLineGap;
  unsigned int otmusMinimumPPEM;
  tagPOINT otmptSubscriptSize;
  tagPOINT otmptSubscriptOffset;
  tagPOINT otmptSuperscriptSize;
  tagPOINT otmptSuperscriptOffset;
  unsigned int otmsStrikeoutSize;
  int otmsStrikeoutPosition;
  int otmsUnderscoreSize;
  int otmsUnderscorePosition;
  char *otmpFamilyName;
  char *otmpFaceName;
  char *otmpStyleName;
  char *otmpFullName;
};


struct sockaddr_in
{
  __int16 sin_family;
  unsigned __int16 sin_port;
  in_addr sin_addr;
  char sin_zero[8];
};


struct _CERT_CRL_CONTEXT_PAIR
{
  _CERT_CONTEXT *pCertContext;
  _CRL_CONTEXT *pCrlContext;
};


struct _DOCINFOA
{
  int cbSize;
  const char *lpszDocName;
  const char *lpszOutput;
  const char *lpszDatatype;
  unsigned int fwType;
};


struct MENUITEMTEMPLATEHEADER
{
  unsigned __int16 versionNumber;
  unsigned __int16 offset;
};


struct _SYSTEM_AUDIT_CALLBACK_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int SidStart;
};


struct _ACTIVATION_CONTEXT_BASIC_INFORMATION
{
  void *hActCtx;
  unsigned int dwFlags;
};


struct tagWNDCLASSA
{
  unsigned int style;
  int (__stdcall *lpfnWndProc)(HWND__ *, unsigned int, unsigned int, int);
  int cbClsExtra;
  int cbWndExtra;
  HINSTANCE__ *hInstance;
  HICON__ *hIcon;
  HICON__ *hCursor;
  HBRUSH__ *hbrBackground;
  const char *lpszMenuName;
  const char *lpszClassName;
};


struct SPC_SIGINFO_
{
  unsigned int dwSipVersion;
  _GUID gSIPGuid;
  unsigned int dwReserved1;
  unsigned int dwReserved2;
  unsigned int dwReserved3;
  unsigned int dwReserved4;
  unsigned int dwReserved5;
};


struct BITMAPV4HEADER
{
  unsigned int bV4Size;
  int bV4Width;
  int bV4Height;
  unsigned __int16 bV4Planes;
  unsigned __int16 bV4BitCount;
  unsigned int bV4V4Compression;
  unsigned int bV4SizeImage;
  int bV4XPelsPerMeter;
  int bV4YPelsPerMeter;
  unsigned int bV4ClrUsed;
  unsigned int bV4ClrImportant;
  unsigned int bV4RedMask;
  unsigned int bV4GreenMask;
  unsigned int bV4BlueMask;
  unsigned int bV4AlphaMask;
  unsigned int bV4CSType;
  tagICEXYZTRIPLE bV4Endpoints;
  unsigned int bV4GammaRed;
  unsigned int bV4GammaGreen;
  unsigned int bV4GammaBlue;
};


struct _BLENDFUNCTION
{
  char BlendOp;
  char BlendFlags;
  char SourceConstantAlpha;
  char AlphaFormat;
};


struct _PUBKEY
{
  unsigned int magic;
  unsigned int bitlen;
};


struct _CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO
{
  unsigned int cbSize;
  _CRYPT_ALGORITHM_IDENTIFIER KeyEncryptionAlgorithm;
  void *pvKeyEncryptionAuxInfo;
  unsigned int hCryptProv;
  _CRYPT_BIT_BLOB RecipientPublicKey;
  _CERT_ID RecipientId;
};


union $56077E50FC1E58EFE4410FB8C9D6FCE1
{
  _CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO *pKeyTrans;
  _CMSG_KEY_AGREE_RECIPIENT_ENCODE_INFO *pKeyAgree;
  _CMSG_MAIL_LIST_RECIPIENT_ENCODE_INFO *pMailList;
};


struct _CMSG_RECIPIENT_ENCODE_INFO
{
  unsigned int dwRecipientChoice;
  $56077E50FC1E58EFE4410FB8C9D6FCE1 ___u1;
};


struct _CMSG_CONTENT_ENCRYPT_INFO
{
  unsigned int cbSize;
  unsigned int hCryptProv;
  _CRYPT_ALGORITHM_IDENTIFIER ContentEncryptionAlgorithm;
  void *pvEncryptionAuxInfo;
  unsigned int cRecipients;
  _CMSG_RECIPIENT_ENCODE_INFO *rgCmsRecipients;
  void *(__stdcall *pfnAlloc)(unsigned int);
  void (__stdcall *pfnFree)(void *);
  unsigned int dwEncryptFlags;
  unsigned int hContentEncryptKey;
  unsigned int dwFlags;
};


struct HUMPD__
{
  int unused;
};


struct _CERT_PRIVATE_KEY_VALIDITY
{
  _FILETIME NotBefore;
  _FILETIME NotAfter;
};


struct _CMSG_KEY_AGREE_KEY_ENCRYPT_INFO
{
  unsigned int cbSize;
  _CRYPTOAPI_BLOB EncryptedKey;
};


struct _CMSG_KEY_AGREE_ENCRYPT_INFO
{
  unsigned int cbSize;
  unsigned int dwRecipientIndex;
  _CRYPT_ALGORITHM_IDENTIFIER KeyEncryptionAlgorithm;
  _CRYPTOAPI_BLOB UserKeyingMaterial;
  unsigned int dwOriginatorChoice;
  $D69F188A98F15D361AD9A0E87EB50039 ___u5;
  unsigned int cKeyAgreeKeyEncryptInfo;
  _CMSG_KEY_AGREE_KEY_ENCRYPT_INFO **rgpKeyAgreeKeyEncryptInfo;
  unsigned int dwFlags;
};


struct _NETRESOURCEA
{
  unsigned int dwScope;
  unsigned int dwType;
  unsigned int dwDisplayType;
  unsigned int dwUsage;
  char *lpLocalName;
  char *lpRemoteName;
  char *lpComment;
  char *lpProvider;
};


struct _KEY_TYPE_SUBTYPE
{
  unsigned int dwKeySpec;
  _GUID Type;
  _GUID Subtype;
};


struct tagEMRCREATEDIBPATTERNBRUSHPT
{
  tagEMR emr;
  unsigned int ihBrush;
  unsigned int iUsage;
  unsigned int offBmi;
  unsigned int cbBmi;
  unsigned int offBits;
  unsigned int cbBits;
};


struct SC_HANDLE__
{
  int unused;
};


struct tagPOINTS
{
  __int16 x;
  __int16 y;
};


struct tagMOUSEINPUT
{
  int dx;
  int dy;
  unsigned int mouseData;
  unsigned int dwFlags;
  unsigned int time;
  unsigned int dwExtraInfo;
};


struct tagKEYBDINPUT
{
  unsigned __int16 wVk;
  unsigned __int16 wScan;
  unsigned int dwFlags;
  unsigned int time;
  unsigned int dwExtraInfo;
};


struct tagHARDWAREINPUT
{
  unsigned int uMsg;
  unsigned __int16 wParamL;
  unsigned __int16 wParamH;
};


union $2602733E8D53C4A22DBA0DCDF7F621E8
{
  tagMOUSEINPUT mi;
  tagKEYBDINPUT ki;
  tagHARDWAREINPUT hi;
};


struct tagINPUT
{
  unsigned int type;
  $2602733E8D53C4A22DBA0DCDF7F621E8 ___u1;
};


struct tagPOINTFX
{
  _FIXED x;
  _FIXED y;
};


struct _PROV_ENUMALGS_EX
{
  unsigned int aiAlgid;
  unsigned int dwDefaultLen;
  unsigned int dwMinLen;
  unsigned int dwMaxLen;
  unsigned int dwProtocols;
  unsigned int dwNameLen;
  char szName[20];
  unsigned int dwLongNameLen;
  char szLongName[40];
};


struct _CERT_X942_DH_VALIDATION_PARAMS
{
  _CRYPT_BIT_BLOB seed;
  unsigned int pgenCounter;
};


struct _CERT_X942_DH_PARAMETERS
{
  _CRYPTOAPI_BLOB p;
  _CRYPTOAPI_BLOB g;
  _CRYPTOAPI_BLOB q;
  _CRYPTOAPI_BLOB j;
  _CERT_X942_DH_VALIDATION_PARAMS *pValidationParams;
};


struct _COMMPROP
{
  unsigned __int16 wPacketLength;
  unsigned __int16 wPacketVersion;
  unsigned int dwServiceMask;
  unsigned int dwReserved1;
  unsigned int dwMaxTxQueue;
  unsigned int dwMaxRxQueue;
  unsigned int dwMaxBaud;
  unsigned int dwProvSubType;
  unsigned int dwProvCapabilities;
  unsigned int dwSettableParams;
  unsigned int dwSettableBaud;
  unsigned __int16 wSettableData;
  unsigned __int16 wSettableStopParity;
  unsigned int dwCurrentTxQueue;
  unsigned int dwCurrentRxQueue;
  unsigned int dwProvSpec1;
  unsigned int dwProvSpec2;
  unsigned __int16 wcProvChar[1];
};


struct tagGUITHREADINFO
{
  unsigned int cbSize;
  unsigned int flags;
  HWND__ *hwndActive;
  HWND__ *hwndFocus;
  HWND__ *hwndCapture;
  HWND__ *hwndMenuOwner;
  HWND__ *hwndMoveSize;
  HWND__ *hwndCaret;
  tagRECT rcCaret;
};


struct HDC__
{
  int unused;
};


struct tagPAINTSTRUCT
{
  HDC__ *hdc;
  int fErase;
  tagRECT rcPaint;
  int fRestore;
  int fIncUpdate;
  char rgbReserved[32];
};


struct _DISCDLGSTRUCTA
{
  unsigned int cbStructure;
  HWND__ *hwndOwner;
  char *lpLocalName;
  char *lpRemoteName;
  unsigned int dwFlags;
};


struct _QUERY_SERVICE_CONFIGW
{
  unsigned int dwServiceType;
  unsigned int dwStartType;
  unsigned int dwErrorControl;
  unsigned __int16 *lpBinaryPathName;
  unsigned __int16 *lpLoadOrderGroup;
  unsigned int dwTagId;
  unsigned __int16 *lpDependencies;
  unsigned __int16 *lpServiceStartName;
  unsigned __int16 *lpDisplayName;
};


struct _MINIDUMP_THREAD
{
  unsigned int ThreadId;
  unsigned int SuspendCount;
  unsigned int PriorityClass;
  unsigned int Priority;
  unsigned __int64 Teb;
  _MINIDUMP_MEMORY_DESCRIPTOR Stack;
  _MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
};


struct HPALETTE__
{
  int unused;
};


struct _IMAGEHLP_MODULE
{
  unsigned int SizeOfStruct;
  unsigned int BaseOfImage;
  unsigned int ImageSize;
  unsigned int TimeDateStamp;
  unsigned int CheckSum;
  unsigned int NumSyms;
  SYM_TYPE SymType;
  char ModuleName[32];
  char ImageName[256];
  char LoadedImageName[256];
};


struct _SINGLE_LIST_ENTRY
{
  _SINGLE_LIST_ENTRY *Next;
};


struct _SYSTEM_ALARM_OBJECT_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int Flags;
  _GUID ObjectType;
  _GUID InheritedObjectType;
  unsigned int SidStart;
};


struct _SYSTEM_AUDIT_CALLBACK_OBJECT_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int Flags;
  _GUID ObjectType;
  _GUID InheritedObjectType;
  unsigned int SidStart;
};


struct tagWNDCLASSEXW
{
  unsigned int cbSize;
  unsigned int style;
  int (__stdcall *lpfnWndProc)(HWND__ *, unsigned int, unsigned int, int);
  int cbClsExtra;
  int cbWndExtra;
  HINSTANCE__ *hInstance;
  HICON__ *hIcon;
  HICON__ *hCursor;
  HBRUSH__ *hbrBackground;
  const unsigned __int16 *lpszMenuName;
  const unsigned __int16 *lpszClassName;
  HICON__ *hIconSm;
};


struct tagMONITORINFO
{
  unsigned int cbSize;
  tagRECT rcMonitor;
  tagRECT rcWork;
  unsigned int dwFlags;
};


struct tagMONITORINFOEXA
{
  tagMONITORINFO baseclass_0;
  char szDevice[32];
};


struct _CMSG_ENCRYPTED_ENCODE_INFO
{
  unsigned int cbSize;
  _CRYPT_ALGORITHM_IDENTIFIER ContentEncryptionAlgorithm;
  void *pvEncryptionAuxInfo;
};


struct tagEMRINVERTRGN
{
  tagEMR emr;
  _RECTL rclBounds;
  unsigned int cbRgnData;
  char RgnData[1];
};


struct _IMAGEHLP_CBA_READ_MEMORY
{
  unsigned __int64 addr;
  void *buf;
  unsigned int bytes;
  unsigned int *bytesread;
};


struct _RTL_VERIFIER_THUNK_DESCRIPTOR
{
  char *ThunkName;
  void *ThunkOldAddress;
  void *ThunkNewAddress;
};


struct _RTL_VERIFIER_DLL_DESCRIPTOR
{
  unsigned __int16 *DllName;
  unsigned int DllFlags;
  void *DllAddress;
  _RTL_VERIFIER_THUNK_DESCRIPTOR *DllThunks;
};


struct _MODEMSETTINGS
{
  unsigned int dwActualSize;
  unsigned int dwRequiredSize;
  unsigned int dwDevSpecificOffset;
  unsigned int dwDevSpecificSize;
  unsigned int dwCallSetupFailTimer;
  unsigned int dwInactivityTimeout;
  unsigned int dwSpeakerVolume;
  unsigned int dwSpeakerMode;
  unsigned int dwPreferredModemOptions;
  unsigned int dwNegotiatedModemOptions;
  unsigned int dwNegotiatedDCERate;
  char abVariablePortion[1];
};


struct tagRGBQUAD
{
  char rgbBlue;
  char rgbGreen;
  char rgbRed;
  char rgbReserved;
};


struct tagBITMAPINFO
{
  tagBITMAPINFOHEADER bmiHeader;
  tagRGBQUAD bmiColors[1];
};


struct _CERT_REVOCATION_PARA
{
  unsigned int cbSize;
  _CERT_CONTEXT *pIssuerCert;
  unsigned int cCertStore;
  void **rgCertStore;
  void *hCrlStore;
  _FILETIME *pftTimeToUse;
};


struct _CMSG_CTRL_DECRYPT_PARA
{
  unsigned int cbSize;
  unsigned int hCryptProv;
  unsigned int dwKeySpec;
  unsigned int dwRecipientIndex;
};


struct _IMAGE_ROM_OPTIONAL_HEADER
{
  unsigned __int16 Magic;
  char MajorLinkerVersion;
  char MinorLinkerVersion;
  unsigned int SizeOfCode;
  unsigned int SizeOfInitializedData;
  unsigned int SizeOfUninitializedData;
  unsigned int AddressOfEntryPoint;
  unsigned int BaseOfCode;
  unsigned int BaseOfData;
  unsigned int BaseOfBss;
  unsigned int GprMask;
  unsigned int CprMask[4];
  unsigned int GpValue;
};


struct _IMAGE_ROM_HEADERS
{
  _IMAGE_FILE_HEADER FileHeader;
  _IMAGE_ROM_OPTIONAL_HEADER OptionalHeader;
};


struct tagSCROLLBARINFO
{
  unsigned int cbSize;
  tagRECT rcScrollBar;
  int dxyLineButton;
  int xyThumbTop;
  int xyThumbBottom;
  int reserved;
  unsigned int rgstate[6];
};


struct _IMAGEHLP_SYMBOL
{
  unsigned int SizeOfStruct;
  unsigned int Address;
  unsigned int Size;
  unsigned int Flags;
  unsigned int MaxNameLength;
  char Name[1];
};


struct _IMAGEHLP_SYMBOL_PACKAGE
{
  _IMAGEHLP_SYMBOL sym;
  char name[2001];
};


struct pvalueA
{
  char *pv_valuename;
  int pv_valuelen;
  void *pv_value_context;
  unsigned int pv_type;
};


struct _TOKEN_USER
{
  _SID_AND_ATTRIBUTES User;
};


struct tagEMREXTTEXTOUTA
{
  tagEMR emr;
  _RECTL rclBounds;
  unsigned int iGraphicsMode;
  float exScale;
  float eyScale;
  tagEMRTEXT emrtext;
};


struct _CMSG_CMS_SIGNER_INFO
{
  unsigned int dwVersion;
  _CERT_ID SignerId;
  _CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm;
  _CRYPT_ALGORITHM_IDENTIFIER HashEncryptionAlgorithm;
  _CRYPTOAPI_BLOB EncryptedHash;
  _CRYPT_ATTRIBUTES AuthAttrs;
  _CRYPT_ATTRIBUTES UnauthAttrs;
};


struct _SPC_SERIALIZED_OBJECT
{
  char ClassId[16];
  _CRYPTOAPI_BLOB SerializedData;
};


union $8723E2E64C686A1561ECE83D44DA5EE2
{
  unsigned __int16 *pwszUrl;
  _SPC_SERIALIZED_OBJECT Moniker;
  unsigned __int16 *pwszFile;
};


struct SPC_LINK_
{
  unsigned int dwLinkChoice;
  $8723E2E64C686A1561ECE83D44DA5EE2 ___u1;
};


struct _SPC_IMAGE
{
  SPC_LINK_ *pImageLink;
  _CRYPTOAPI_BLOB Bitmap;
  _CRYPTOAPI_BLOB Metafile;
  _CRYPTOAPI_BLOB EnhancedMetafile;
  _CRYPTOAPI_BLOB GifFile;
};


struct _SPC_SP_AGENCY_INFO
{
  SPC_LINK_ *pPolicyInformation;
  unsigned __int16 *pwszPolicyDisplayText;
  _SPC_IMAGE *pLogoImage;
  SPC_LINK_ *pLogoLink;
};


struct tagEMRANGLEARC
{
  tagEMR emr;
  _POINTL ptlCenter;
  unsigned int nRadius;
  float eStartAngle;
  float eSweepAngle;
};


struct tagCANDIDATEFORM
{
  unsigned int dwIndex;
  unsigned int dwStyle;
  tagPOINT ptCurrentPos;
  tagRECT rcArea;
};


struct tagEMRSETARCDIRECTION
{
  tagEMR emr;
  unsigned int iArcDirection;
};


struct IMAGE_AUX_SYMBOL_TOKEN_DEF
{
  char bAuxType;
  char bReserved;
  unsigned int SymbolTableIndex;
  char rgbReserved[12];
};


struct tagLAYERPLANEDESCRIPTOR
{
  unsigned __int16 nSize;
  unsigned __int16 nVersion;
  unsigned int dwFlags;
  char iPixelType;
  char cColorBits;
  char cRedBits;
  char cRedShift;
  char cGreenBits;
  char cGreenShift;
  char cBlueBits;
  char cBlueShift;
  char cAlphaBits;
  char cAlphaShift;
  char cAccumBits;
  char cAccumRedBits;
  char cAccumGreenBits;
  char cAccumBlueBits;
  char cAccumAlphaBits;
  char cDepthBits;
  char cStencilBits;
  char cAuxBuffers;
  char iLayerPlane;
  char bReserved;
  unsigned int crTransparent;
};


struct _TAPE_SET_POSITION
{
  unsigned int Method;
  unsigned int Partition;
  _LARGE_INTEGER Offset;
  char Immediate;
};


struct _numberfmtW
{
  unsigned int NumDigits;
  unsigned int LeadingZero;
  unsigned int Grouping;
  unsigned __int16 *lpDecimalSep;
  unsigned __int16 *lpThousandSep;
  unsigned int NegativeOrder;
};


struct _CONNECTDLGSTRUCTA
{
  unsigned int cbStructure;
  HWND__ *hwndOwner;
  _NETRESOURCEA *lpConnRes;
  unsigned int dwFlags;
  unsigned int dwDevNum;
};


struct _CRYPT_PASSWORD_CREDENTIALSA
{
  unsigned int cbSize;
  char *pszUsername;
  char *pszPassword;
};


struct _CERT_REQUEST_INFO
{
  unsigned int dwVersion;
  _CRYPTOAPI_BLOB Subject;
  _CERT_PUBLIC_KEY_INFO SubjectPublicKeyInfo;
  unsigned int cAttribute;
  _CRYPT_ATTRIBUTE *rgAttribute;
};


union _IMAGE_LINENUMBER::__unnamed
{
  unsigned int SymbolTableIndex;
  unsigned int VirtualAddress;
};


struct _IMAGE_LINENUMBER
{
  _IMAGE_LINENUMBER::__unnamed Type;
  unsigned __int16 Linenumber;
};


struct _EXCEPTION_DEBUG_INFO
{
  _EXCEPTION_RECORD ExceptionRecord;
  unsigned int dwFirstChance;
};


struct _CERT_POLICY_QUALIFIER_INFO
{
  char *pszPolicyQualifierId;
  _CRYPTOAPI_BLOB Qualifier;
};


struct _CERT_POLICY_INFO
{
  char *pszPolicyIdentifier;
  unsigned int cPolicyQualifier;
  _CERT_POLICY_QUALIFIER_INFO *rgPolicyQualifier;
};


struct _CERT_POLICIES_INFO
{
  unsigned int cPolicyInfo;
  _CERT_POLICY_INFO *rgPolicyInfo;
};


struct _CMSG_CTRL_KEY_TRANS_DECRYPT_PARA
{
  unsigned int cbSize;
  unsigned int hCryptProv;
  unsigned int dwKeySpec;
  _CMSG_KEY_TRANS_RECIPIENT_INFO *pKeyTrans;
  unsigned int dwRecipientIndex;
};


struct _DISPLAY_DEVICEA
{
  unsigned int cb;
  char DeviceName[32];
  char DeviceString[128];
  unsigned int StateFlags;
  char DeviceID[128];
  char DeviceKey[128];
};


struct tagWCRANGE
{
  unsigned __int16 wcLow;
  unsigned __int16 cGlyphs;
};


struct _IMAGE_DEBUG_MISC
{
  unsigned int DataType;
  unsigned int Length;
  char Unicode;
  char Reserved[3];
  char Data[1];
};


struct _CERT_PHYSICAL_STORE_INFO
{
  unsigned int cbSize;
  char *pszOpenStoreProvider;
  unsigned int dwOpenEncodingType;
  unsigned int dwOpenFlags;
  _CRYPTOAPI_BLOB OpenParameters;
  unsigned int dwFlags;
  unsigned int dwPriority;
};


struct HENHMETAFILE__
{
  int unused;
};


struct _CERT_KEYGEN_REQUEST_INFO
{
  unsigned int dwVersion;
  _CERT_PUBLIC_KEY_INFO SubjectPublicKeyInfo;
  unsigned __int16 *pwszChallengeString;
};


struct _MINIDUMP_FUNCTION_TABLE_STREAM
{
  unsigned int SizeOfHeader;
  unsigned int SizeOfDescriptor;
  unsigned int SizeOfNativeDescriptor;
  unsigned int SizeOfFunctionEntry;
  unsigned int NumberOfDescriptors;
  unsigned int SizeOfAlignPad;
};


struct _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY
{
  unsigned int BeginAddress;
  unsigned int EndAddress;
  unsigned int ExceptionHandler;
  unsigned int HandlerData;
  unsigned int PrologEndAddress;
};


struct _SOCKET_ADDRESS_LIST
{
  int iAddressCount;
  _SOCKET_ADDRESS Address[1];
};


struct _MINIDUMP_INCLUDE_MODULE_CALLBACK
{
  unsigned __int64 BaseOfImage;
};


struct _OSVERSIONINFOW
{
  unsigned int dwOSVersionInfoSize;
  unsigned int dwMajorVersion;
  unsigned int dwMinorVersion;
  unsigned int dwBuildNumber;
  unsigned int dwPlatformId;
  unsigned __int16 szCSDVersion[128];
};


struct tagRECONVERTSTRING
{
  unsigned int dwSize;
  unsigned int dwVersion;
  unsigned int dwStrLen;
  unsigned int dwStrOffset;
  unsigned int dwCompStrLen;
  unsigned int dwCompStrOffset;
  unsigned int dwTargetStrLen;
  unsigned int dwTargetStrOffset;
};


struct _EXCEPTION_RECORD32
{
  unsigned int ExceptionCode;
  unsigned int ExceptionFlags;
  unsigned int ExceptionRecord;
  unsigned int ExceptionAddress;
  unsigned int NumberParameters;
  unsigned int ExceptionInformation[15];
};


struct _CRYPT_ENCODE_PARA
{
  unsigned int cbSize;
  void *(__stdcall *pfnAlloc)(unsigned int);
  void (__stdcall *pfnFree)(void *);
};


struct tagEMREXTSELECTCLIPRGN
{
  tagEMR emr;
  unsigned int cbRgnData;
  unsigned int iMode;
  char RgnData[1];
};


struct _CERT_TEMPLATE_EXT
{
  char *pszObjId;
  unsigned int dwMajorVersion;
  int fMinorVersion;
  unsigned int dwMinorVersion;
};


struct _STARTUPINFOW
{
  unsigned int cb;
  unsigned __int16 *lpReserved;
  unsigned __int16 *lpDesktop;
  unsigned __int16 *lpTitle;
  unsigned int dwX;
  unsigned int dwY;
  unsigned int dwXSize;
  unsigned int dwYSize;
  unsigned int dwXCountChars;
  unsigned int dwYCountChars;
  unsigned int dwFillAttribute;
  unsigned int dwFlags;
  unsigned __int16 wShowWindow;
  unsigned __int16 cbReserved2;
  char *lpReserved2;
  void *hStdInput;
  void *hStdOutput;
  void *hStdError;
};


struct tagSTICKYKEYS
{
  unsigned int cbSize;
  unsigned int dwFlags;
};


struct tagTITLEBARINFO
{
  unsigned int cbSize;
  tagRECT rcTitleBar;
  unsigned int rgstate[6];
};


struct _CERT_KEY_ATTRIBUTES_INFO
{
  _CRYPTOAPI_BLOB KeyId;
  _CRYPT_BIT_BLOB IntendedKeyUsage;
  _CERT_PRIVATE_KEY_VALIDITY *pPrivateKeyUsagePeriod;
};


struct tagAXISINFOW
{
  int axMinValue;
  int axMaxValue;
  unsigned __int16 axAxisName[16];
};


struct tagENUMLOGFONTA
{
  tagLOGFONTA elfLogFont;
  char elfFullName[64];
  char elfStyle[32];
};


struct tagEMRALPHABLEND
{
  tagEMR emr;
  _RECTL rclBounds;
  int xDest;
  int yDest;
  int cxDest;
  int cyDest;
  unsigned int dwRop;
  int xSrc;
  int ySrc;
  tagXFORM xformSrc;
  unsigned int crBkColorSrc;
  unsigned int iUsageSrc;
  unsigned int offBmiSrc;
  unsigned int cbBmiSrc;
  unsigned int offBitsSrc;
  unsigned int cbBitsSrc;
  int cxSrc;
  int cySrc;
};


struct tagMOUSEHOOKSTRUCT
{
  tagPOINT pt;
  HWND__ *hwnd;
  unsigned int wHitTestCode;
  unsigned int dwExtraInfo;
};


struct _CRYPT_CONTENT_INFO
{
  char *pszObjId;
  _CRYPTOAPI_BLOB Content;
};


struct tagEMRGLSRECORD
{
  tagEMR emr;
  unsigned int cbData;
  char Data[1];
};


struct tagMOUSEKEYS
{
  unsigned int cbSize;
  unsigned int dwFlags;
  unsigned int iMaxSpeed;
  unsigned int iTimeToMaxSpeed;
  unsigned int iCtrlSpeed;
  unsigned int dwReserved1;
  unsigned int dwReserved2;
};


struct HACCEL__
{
  int unused;
};


struct _SPC_FINANCIAL_CRITERIA
{
  int fFinancialInfoAvailable;
  int fMeetsCriteria;
};


struct tagEMRSTRETCHBLT
{
  tagEMR emr;
  _RECTL rclBounds;
  int xDest;
  int yDest;
  int cxDest;
  int cyDest;
  unsigned int dwRop;
  int xSrc;
  int ySrc;
  tagXFORM xformSrc;
  unsigned int crBkColorSrc;
  unsigned int iUsageSrc;
  unsigned int offBmiSrc;
  unsigned int cbBmiSrc;
  unsigned int offBitsSrc;
  unsigned int cbBitsSrc;
  int cxSrc;
  int cySrc;
};


struct _ACCESS_DENIED_CALLBACK_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int SidStart;
};


struct _TOKEN_GROUPS
{
  unsigned int GroupCount;
  _SID_AND_ATTRIBUTES Groups[1];
};


struct _TOKEN_PRIVILEGES
{
  unsigned int PrivilegeCount;
  _LUID_AND_ATTRIBUTES Privileges[1];
};


struct _JOBOBJECT_SECURITY_LIMIT_INFORMATION
{
  unsigned int SecurityLimitFlags;
  void *JobToken;
  _TOKEN_GROUPS *SidsToDisable;
  _TOKEN_PRIVILEGES *PrivilegesToDelete;
  _TOKEN_GROUPS *RestrictedSids;
};


union _IMAGE_THUNK_DATA32::__unnamed
{
  unsigned int ForwarderString;
  unsigned int Function;
  unsigned int Ordinal;
  unsigned int AddressOfData;
};


struct _IMAGE_THUNK_DATA32
{
  _IMAGE_THUNK_DATA32::__unnamed u1;
};


struct _IMAGE_CE_RUNTIME_FUNCTION_ENTRY
{
  unsigned int FuncStart;
  int _bf4;
};


struct tagSERIALKEYSA
{
  unsigned int cbSize;
  unsigned int dwFlags;
  char *lpszActivePort;
  char *lpszPort;
  unsigned int iBaudRate;
  unsigned int iPortState;
  unsigned int iActive;
};


struct ANON_OBJECT_HEADER
{
  unsigned __int16 Sig1;
  unsigned __int16 Sig2;
  unsigned __int16 Version;
  unsigned __int16 Machine;
  unsigned int TimeDateStamp;
  _GUID ClassID;
  unsigned int SizeOfData;
};


struct tagEMREXTESCAPE
{
  tagEMR emr;
  int iEscape;
  int cbEscData;
  char EscData[1];
};


struct tagLOGCOLORSPACEA
{
  unsigned int lcsSignature;
  unsigned int lcsVersion;
  unsigned int lcsSize;
  int lcsCSType;
  int lcsIntent;
  tagICEXYZTRIPLE lcsEndpoints;
  unsigned int lcsGammaRed;
  unsigned int lcsGammaGreen;
  unsigned int lcsGammaBlue;
  char lcsFilename[260];
};


struct tagEMRCREATECOLORSPACE
{
  tagEMR emr;
  unsigned int ihCS;
  tagLOGCOLORSPACEA lcs;
};


struct _MINIDUMP_USER_STREAM
{
  unsigned int Type;
  unsigned int BufferSize;
  void *Buffer;
};


struct _WSAPROTOCOL_INFOW
{
  unsigned int dwServiceFlags1;
  unsigned int dwServiceFlags2;
  unsigned int dwServiceFlags3;
  unsigned int dwServiceFlags4;
  unsigned int dwProviderFlags;
  _GUID ProviderId;
  unsigned int dwCatalogEntryId;
  _WSAPROTOCOLCHAIN ProtocolChain;
  int iVersion;
  int iAddressFamily;
  int iMaxSockAddr;
  int iMinSockAddr;
  int iSocketType;
  int iProtocol;
  int iProtocolMaxOffset;
  int iNetworkByteOrder;
  int iSecurityScheme;
  unsigned int dwMessageSize;
  unsigned int dwProviderReserved;
  unsigned __int16 szProtocol[256];
};


struct _IMAGE_VXD_HEADER
{
  unsigned __int16 e32_magic;
  char e32_border;
  char e32_worder;
  unsigned int e32_level;
  unsigned __int16 e32_cpu;
  unsigned __int16 e32_os;
  unsigned int e32_ver;
  unsigned int e32_mflags;
  unsigned int e32_mpages;
  unsigned int e32_startobj;
  unsigned int e32_eip;
  unsigned int e32_stackobj;
  unsigned int e32_esp;
  unsigned int e32_pagesize;
  unsigned int e32_lastpagesize;
  unsigned int e32_fixupsize;
  unsigned int e32_fixupsum;
  unsigned int e32_ldrsize;
  unsigned int e32_ldrsum;
  unsigned int e32_objtab;
  unsigned int e32_objcnt;
  unsigned int e32_objmap;
  unsigned int e32_itermap;
  unsigned int e32_rsrctab;
  unsigned int e32_rsrccnt;
  unsigned int e32_restab;
  unsigned int e32_enttab;
  unsigned int e32_dirtab;
  unsigned int e32_dircnt;
  unsigned int e32_fpagetab;
  unsigned int e32_frectab;
  unsigned int e32_impmod;
  unsigned int e32_impmodcnt;
  unsigned int e32_impproc;
  unsigned int e32_pagesum;
  unsigned int e32_datapage;
  unsigned int e32_preload;
  unsigned int e32_nrestab;
  unsigned int e32_cbnrestab;
  unsigned int e32_nressum;
  unsigned int e32_autodata;
  unsigned int e32_debuginfo;
  unsigned int e32_debuglen;
  unsigned int e32_instpreload;
  unsigned int e32_instdemand;
  unsigned int e32_heapsize;
  char e32_res3[12];
  unsigned int e32_winresoff;
  unsigned int e32_winreslen;
  unsigned __int16 e32_devid;
  unsigned __int16 e32_ddkver;
};


struct _MINIDUMP_EXCEPTION_INFORMATION
{
  unsigned int ThreadId;
  _EXCEPTION_POINTERS *ExceptionPointers;
  int ClientPointers;
};


struct tagEMRSETWORLDTRANSFORM
{
  tagEMR emr;
  tagXFORM xform;
};


struct _CERT_POLICY_MAPPING
{
  char *pszIssuerDomainPolicy;
  char *pszSubjectDomainPolicy;
};


struct _CERT_POLICY_MAPPINGS_INFO
{
  unsigned int cPolicyMapping;
  _CERT_POLICY_MAPPING *rgPolicyMapping;
};


struct tagMULTIKEYHELPA
{
  unsigned int mkSize;
  char mkKeylist;
  char szKeyphrase[1];
};


struct _CMSG_MAIL_LIST_ENCRYPT_INFO
{
  unsigned int cbSize;
  unsigned int dwRecipientIndex;
  _CRYPT_ALGORITHM_IDENTIFIER KeyEncryptionAlgorithm;
  _CRYPTOAPI_BLOB EncryptedKey;
  unsigned int dwFlags;
};


struct _CERT_CHAIN_POLICY_PARA
{
  unsigned int cbSize;
  unsigned int dwFlags;
  void *pvExtraPolicyPara;
};


struct _MINIDUMP_THREAD_EX
{
  unsigned int ThreadId;
  unsigned int SuspendCount;
  unsigned int PriorityClass;
  unsigned int Priority;
  unsigned __int64 Teb;
  _MINIDUMP_MEMORY_DESCRIPTOR Stack;
  _MINIDUMP_LOCATION_DESCRIPTOR ThreadContext;
  _MINIDUMP_MEMORY_DESCRIPTOR BackingStore;
};


struct _MINIDUMP_THREAD_EX_LIST
{
  unsigned int NumberOfThreads;
  _MINIDUMP_THREAD_EX Threads[];
};


struct _CERT_POLICY_CONSTRAINTS_INFO
{
  int fRequireExplicitPolicy;
  unsigned int dwRequireExplicitPolicySkipCerts;
  int fInhibitPolicyMapping;
  unsigned int dwInhibitPolicyMappingSkipCerts;
};


struct _WIN32_FILE_ATTRIBUTE_DATA
{
  unsigned int dwFileAttributes;
  _FILETIME ftCreationTime;
  _FILETIME ftLastAccessTime;
  _FILETIME ftLastWriteTime;
  unsigned int nFileSizeHigh;
  unsigned int nFileSizeLow;
};


struct _CRL_DIST_POINT_NAME
{
  unsigned int dwDistPointNameChoice;
  _CERT_ALT_NAME_INFO FullName;
};


struct _CRYPT_PASSWORD_CREDENTIALSW
{
  unsigned int cbSize;
  unsigned __int16 *pszUsername;
  unsigned __int16 *pszPassword;
};


struct _OSVERSIONINFOEXA
{
  unsigned int dwOSVersionInfoSize;
  unsigned int dwMajorVersion;
  unsigned int dwMinorVersion;
  unsigned int dwBuildNumber;
  unsigned int dwPlatformId;
  char szCSDVersion[128];
  unsigned __int16 wServicePackMajor;
  unsigned __int16 wServicePackMinor;
  unsigned __int16 wSuiteMask;
  char wProductType;
  char wReserved;
};


struct _ImageArchitectureHeader
{
  int _bf0;
  unsigned int FirstEntryRVA;
};


struct _SYSTEM_POWER_STATUS
{
  char ACLineStatus;
  char BatteryFlag;
  char BatteryLifePercent;
  char Reserved1;
  unsigned int BatteryLifeTime;
  unsigned int BatteryFullLifeTime;
};


struct tagEMRPOLYLINE16
{
  tagEMR emr;
  _RECTL rclBounds;
  unsigned int cpts;
  tagPOINTS apts[1];
};


struct tagMENUBARINFO
{
  unsigned int cbSize;
  tagRECT rcBar;
  HMENU__ *hMenu;
  HWND__ *hwndMenu;
  int _bf28;
};


struct _WSABUF
{
  unsigned int len;
  char *buf;
};


struct _IMAGEHLP_STACK_FRAME
{
  unsigned __int64 InstructionOffset;
  unsigned __int64 ReturnOffset;
  unsigned __int64 FrameOffset;
  unsigned __int64 StackOffset;
  unsigned __int64 BackingStoreOffset;
  unsigned __int64 FuncTableEntry;
  unsigned __int64 Params[4];
  unsigned __int64 Reserved[5];
  int Virtual;
  unsigned int Reserved2;
};


struct _ACCESS_DENIED_CALLBACK_OBJECT_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int Flags;
  _GUID ObjectType;
  _GUID InheritedObjectType;
  unsigned int SidStart;
};


struct _CRYPT_CONTENT_INFO_SEQUENCE_OF_ANY
{
  char *pszObjId;
  unsigned int cValue;
  _CRYPTOAPI_BLOB *rgValue;
};


struct tagEMRSCALEVIEWPORTEXTEX
{
  tagEMR emr;
  int xNum;
  int xDenom;
  int yNum;
  int yDenom;
};


struct DLGTEMPLATE
{
  unsigned int style;
  unsigned int dwExtendedStyle;
  unsigned __int16 cdit;
  __int16 x;
  __int16 y;
  __int16 cx;
  __int16 cy;
};


struct tagEMRELLIPSE
{
  tagEMR emr;
  _RECTL rclBox;
};


struct _ACCESS_ALLOWED_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int SidStart;
};


struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION::__unnamed::__unnamed
{
  char Flags;
};


union $EB5C4764306826CFC492C43E720BD5E9
{
  _SYSTEM_LOGICAL_PROCESSOR_INFORMATION::__unnamed::__unnamed ProcessorCore;
  _SYSTEM_LOGICAL_PROCESSOR_INFORMATION::__unnamed::__unnamed NumaNode;
  unsigned __int64 Reserved[2];
};


struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION
{
  unsigned int ProcessorMask;
  _LOGICAL_PROCESSOR_RELATIONSHIP Relationship;
  $EB5C4764306826CFC492C43E720BD5E9 ___u2;
};


struct tagENHMETAHEADER
{
  unsigned int iType;
  unsigned int nSize;
  _RECTL rclBounds;
  _RECTL rclFrame;
  unsigned int dSignature;
  unsigned int nVersion;
  unsigned int nBytes;
  unsigned int nRecords;
  unsigned __int16 nHandles;
  unsigned __int16 sReserved;
  unsigned int nDescription;
  unsigned int offDescription;
  unsigned int nPalEntries;
  tagSIZE szlDevice;
  tagSIZE szlMillimeters;
  unsigned int cbPixelFormat;
  unsigned int offPixelFormat;
  unsigned int bOpenGL;
  tagSIZE szlMicrometers;
};


struct _CMSG_CTRL_KEY_AGREE_DECRYPT_PARA
{
  unsigned int cbSize;
  unsigned int hCryptProv;
  unsigned int dwKeySpec;
  _CMSG_KEY_AGREE_RECIPIENT_INFO *pKeyAgree;
  unsigned int dwRecipientIndex;
  unsigned int dwRecipientEncryptedKeyIndex;
  _CRYPT_BIT_BLOB OriginatorPublicKey;
};


struct _TAPE_WMI_OPERATIONS
{
  unsigned int Method;
  unsigned int DataBufferSize;
  void *DataBuffer;
};


struct _devicemodeW
{
  unsigned __int16 dmDeviceName[32];
  unsigned __int16 dmSpecVersion;
  unsigned __int16 dmDriverVersion;
  unsigned __int16 dmSize;
  unsigned __int16 dmDriverExtra;
  unsigned int dmFields;
  $CA2C2170EABAD629BBBFEDAA95C12DEB ___u6;
  $E29B8DCD6F939C9CF7074045C83AF3EE ___u7;
  $7D362512FEF071268FC3C90790B478CC ___u8;
  __int16 dmColor;
  __int16 dmDuplex;
  __int16 dmYResolution;
  __int16 dmTTOption;
  __int16 dmCollate;
  unsigned __int16 dmFormName[32];
  unsigned __int16 dmLogPixels;
  unsigned int dmBitsPerPel;
  unsigned int dmPelsWidth;
  unsigned int dmPelsHeight;
  $309666D137CBB19809FA597AD348B415 ___u19;
  unsigned int dmDisplayFrequency;
  unsigned int dmICMMethod;
  unsigned int dmICMIntent;
  unsigned int dmMediaType;
  unsigned int dmDitherType;
  unsigned int dmReserved1;
  unsigned int dmReserved2;
  unsigned int dmPanningWidth;
  unsigned int dmPanningHeight;
};


struct _CRYPT_DEFAULT_CONTEXT_MULTI_OID_PARA
{
  unsigned int cOID;
  char **rgpszOID;
};


struct _WSANAMESPACE_INFOW
{
  _GUID NSProviderId;
  unsigned int dwNameSpace;
  int fActive;
  unsigned int dwVersion;
  unsigned __int16 *lpszIdentifier;
};


struct HFONT__
{
  int unused;
};


struct tagMOUSEMOVEPOINT
{
  int x;
  int y;
  unsigned int time;
  unsigned int dwExtraInfo;
};


struct tagHIGHCONTRASTA
{
  unsigned int cbSize;
  unsigned int dwFlags;
  char *lpszDefaultScheme;
};


struct _CERT_AUTHORITY_INFO_ACCESS
{
  unsigned int cAccDescr;
  _CERT_ACCESS_DESCRIPTION *rgAccDescr;
};


struct _MINIDUMP_THREAD_CALLBACK
{
  unsigned int ThreadId;
  void *ThreadHandle;
  _CONTEXT Context;
  unsigned int SizeOfContext;
  unsigned __int64 StackBase;
  unsigned __int64 StackEnd;
};


struct _MINIDUMP_THREAD_EX_CALLBACK
{
  unsigned int ThreadId;
  void *ThreadHandle;
  _CONTEXT Context;
  unsigned int SizeOfContext;
  unsigned __int64 StackBase;
  unsigned __int64 StackEnd;
  unsigned __int64 BackingStoreBase;
  unsigned __int64 BackingStoreEnd;
};


struct tagVS_FIXEDFILEINFO
{
  unsigned int dwSignature;
  unsigned int dwStrucVersion;
  unsigned int dwFileVersionMS;
  unsigned int dwFileVersionLS;
  unsigned int dwProductVersionMS;
  unsigned int dwProductVersionLS;
  unsigned int dwFileFlagsMask;
  unsigned int dwFileFlags;
  unsigned int dwFileOS;
  unsigned int dwFileType;
  unsigned int dwFileSubtype;
  unsigned int dwFileDateMS;
  unsigned int dwFileDateLS;
};


struct _MINIDUMP_MODULE_CALLBACK
{
  unsigned __int16 *FullPath;
  unsigned __int64 BaseOfImage;
  unsigned int SizeOfImage;
  unsigned int CheckSum;
  unsigned int TimeDateStamp;
  tagVS_FIXEDFILEINFO VersionInfo;
  void *CvRecord;
  unsigned int SizeOfCvRecord;
  void *MiscRecord;
  unsigned int SizeOfMiscRecord;
};


struct _MINIDUMP_INCLUDE_THREAD_CALLBACK
{
  unsigned int ThreadId;
};


union $A05FFEAD05A63F70B3B44E7B3E808166
{
  _MINIDUMP_THREAD_CALLBACK Thread;
  _MINIDUMP_THREAD_EX_CALLBACK ThreadEx;
  _MINIDUMP_MODULE_CALLBACK Module;
  _MINIDUMP_INCLUDE_THREAD_CALLBACK IncludeThread;
  _MINIDUMP_INCLUDE_MODULE_CALLBACK IncludeModule;
};


struct _MINIDUMP_CALLBACK_INPUT
{
  unsigned int ProcessId;
  void *ProcessHandle;
  unsigned int CallbackType;
  $A05FFEAD05A63F70B3B44E7B3E808166 ___u3;
};


union $DD82D2F84ECA88824B89F98F568C2145
{
  unsigned int ModuleWriteFlags;
  unsigned int ThreadWriteFlags;
};


struct _MINIDUMP_CALLBACK_OUTPUT
{
  $DD82D2F84ECA88824B89F98F568C2145 ___u0;
};


struct _MINIDUMP_CALLBACK_INFORMATION
{
  int (__stdcall *CallbackRoutine)(void *, _MINIDUMP_CALLBACK_INPUT *const , _MINIDUMP_CALLBACK_OUTPUT *);
  void *CallbackParam;
};


struct _WSANSClassInfoW
{
  unsigned __int16 *lpszName;
  unsigned int dwNameSpace;
  unsigned int dwValueType;
  unsigned int dwValueSize;
  void *lpValue;
};


struct _OSVERSIONINFOA
{
  unsigned int dwOSVersionInfoSize;
  unsigned int dwMajorVersion;
  unsigned int dwMinorVersion;
  unsigned int dwBuildNumber;
  unsigned int dwPlatformId;
  char szCSDVersion[128];
};


struct tagEMRSETICMPROFILE
{
  tagEMR emr;
  unsigned int dwFlags;
  unsigned int cbName;
  unsigned int cbData;
  char Data[1];
};


struct _CERT_GENERAL_SUBTREE
{
  _CERT_ALT_NAME_ENTRY Base;
  unsigned int dwMinimum;
  int fMaximum;
  unsigned int dwMaximum;
};


struct _CERT_KEY_CONTEXT
{
  unsigned int cbSize;
  unsigned int hCryptProv;
  unsigned int dwKeySpec;
};


struct _IMAGE_BASE_RELOCATION
{
  unsigned int VirtualAddress;
  unsigned int SizeOfBlock;
};


union $B5432B5766EACA8D7A891B0C9CA17601
{
  unsigned int cbStruct;
  unsigned int cbSize;
};


struct _HTTPSPolicyCallbackData
{
  $B5432B5766EACA8D7A891B0C9CA17601 ___u0;
  unsigned int dwAuthType;
  unsigned int fdwChecks;
  unsigned __int16 *pwszServerName;
};


struct WSAData
{
  unsigned __int16 wVersion;
  unsigned __int16 wHighVersion;
  char szDescription[257];
  char szSystemStatus[129];
  unsigned __int16 iMaxSockets;
  unsigned __int16 iMaxUdpDg;
  char *lpVendorInfo;
};


struct tagCANDIDATELIST
{
  unsigned int dwSize;
  unsigned int dwStyle;
  unsigned int dwCount;
  unsigned int dwSelection;
  unsigned int dwPageStart;
  unsigned int dwPageSize;
  unsigned int dwOffset[1];
};


struct tagACCESSTIMEOUT
{
  unsigned int cbSize;
  unsigned int dwFlags;
  unsigned int iTimeOutMSec;
};


struct _CMSG_CTRL_ADD_SIGNER_UNAUTH_ATTR_PARA
{
  unsigned int cbSize;
  unsigned int dwSignerIndex;
  _CRYPTOAPI_BLOB blob;
};


struct _JOBOBJECT_ASSOCIATE_COMPLETION_PORT
{
  void *CompletionKey;
  void *CompletionPort;
};


struct HWINEVENTHOOK__
{
  int unused;
};


struct _CMC_TAGGED_CERT_REQUEST
{
  unsigned int dwBodyPartID;
  _CRYPTOAPI_BLOB SignedCertRequest;
};


struct _CMC_TAGGED_REQUEST
{
  unsigned int dwTaggedRequestChoice;
  _CMC_TAGGED_CERT_REQUEST *pTaggedCertRequest;
};


struct tagMENUGETOBJECTINFO
{
  unsigned int dwFlags;
  unsigned int uPos;
  HMENU__ *hmenu;
  void *riid;
  void *pvObj;
};


struct _CMS_KEY_INFO
{
  unsigned int dwVersion;
  unsigned int Algid;
  char *pbOID;
  unsigned int cbOID;
};


struct _CTL_VERIFY_USAGE_PARA
{
  unsigned int cbSize;
  _CRYPTOAPI_BLOB ListIdentifier;
  unsigned int cCtlStore;
  void **rghCtlStore;
  unsigned int cSignerStore;
  void **rghSignerStore;
};


struct _MINIDUMP_UNLOADED_MODULE_LIST
{
  unsigned int SizeOfHeader;
  unsigned int SizeOfEntry;
  unsigned int NumberOfEntries;
};


struct _CMSG_KEY_TRANS_ENCRYPT_INFO
{
  unsigned int cbSize;
  unsigned int dwRecipientIndex;
  _CRYPT_ALGORITHM_IDENTIFIER KeyEncryptionAlgorithm;
  _CRYPTOAPI_BLOB EncryptedKey;
  unsigned int dwFlags;
};


struct _MESSAGE_RESOURCE_ENTRY
{
  unsigned __int16 Length;
  unsigned __int16 Flags;
  char Text[1];
};


struct tagHIGHCONTRASTW
{
  unsigned int cbSize;
  unsigned int dwFlags;
  unsigned __int16 *lpszDefaultScheme;
};


struct _CRYPT_RETRIEVE_AUX_INFO
{
  unsigned int cbSize;
  _FILETIME *pLastSyncTime;
  unsigned int dwMaxUrlRetrievalByteCount;
};


struct _MINIDUMP_MODULE
{
  unsigned __int64 BaseOfImage;
  unsigned int SizeOfImage;
  unsigned int CheckSum;
  unsigned int TimeDateStamp;
  unsigned int ModuleNameRva;
  tagVS_FIXEDFILEINFO VersionInfo;
  _MINIDUMP_LOCATION_DESCRIPTOR CvRecord;
  _MINIDUMP_LOCATION_DESCRIPTOR MiscRecord;
  unsigned __int64 Reserved0;
  unsigned __int64 Reserved1;
};


struct tagPOLYTEXTW
{
  int x;
  int y;
  unsigned int n;
  const unsigned __int16 *lpstr;
  unsigned int uiFlags;
  tagRECT rcl;
  int *pdx;
};


struct _CRL_REVOCATION_INFO
{
  _CRL_ENTRY *pCrlEntry;
  _CRL_CONTEXT *pCrlContext;
  _CERT_CHAIN_CONTEXT *pCrlIssuerChain;
};


struct _flowspec
{
  unsigned int TokenRate;
  unsigned int TokenBucketSize;
  unsigned int PeakBandwidth;
  unsigned int Latency;
  unsigned int DelayVariation;
  unsigned int ServiceType;
  unsigned int MaxSduSize;
  unsigned int MinimumPolicedSize;
};


struct _QualityOfService
{
  _flowspec SendingFlowspec;
  _flowspec ReceivingFlowspec;
  _WSABUF ProviderSpecific;
};


struct SYSTEM_BATTERY_STATE
{
  char AcOnLine;
  char BatteryPresent;
  char Charging;
  char Discharging;
  char Spare1[4];
  unsigned int MaxCapacity;
  unsigned int RemainingCapacity;
  unsigned int Rate;
  unsigned int EstimatedTime;
  unsigned int DefaultAlert1;
  unsigned int DefaultAlert2;
};


struct tagICONMETRICSA
{
  unsigned int cbSize;
  int iHorzSpacing;
  int iVertSpacing;
  int iTitleWrap;
  tagLOGFONTA lfFont;
};


struct _nlsversioninfo
{
  unsigned int dwNLSVersionInfoSize;
  unsigned int dwNLSVersion;
  unsigned int dwDefinedVersion;
};


struct HMETAFILE__
{
  int unused;
};


struct tagMETAFILEPICT
{
  int mm;
  int xExt;
  int yExt;
  HMETAFILE__ *hMF;
};


struct tagAXESLISTW
{
  unsigned int axlReserved;
  unsigned int axlNumAxes;
  tagAXISINFOW axlAxisInfo[16];
};


struct _FOCUS_EVENT_RECORD
{
  int bSetFocus;
};


struct _CRYPT_HASH_MESSAGE_PARA
{
  unsigned int cbSize;
  unsigned int dwMsgEncodingType;
  unsigned int hCryptProv;
  _CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm;
  void *pvHashAuxInfo;
};


struct _KDHELP64
{
  unsigned __int64 Thread;
  unsigned int ThCallbackStack;
  unsigned int ThCallbackBStore;
  unsigned int NextCallback;
  unsigned int FramePointer;
  unsigned __int64 KiCallUserMode;
  unsigned __int64 KeUserCallbackDispatcher;
  unsigned __int64 SystemRangeStart;
  unsigned __int64 Reserved[8];
};


struct _tagSTACKFRAME64
{
  _tagADDRESS64 AddrPC;
  _tagADDRESS64 AddrReturn;
  _tagADDRESS64 AddrFrame;
  _tagADDRESS64 AddrStack;
  _tagADDRESS64 AddrBStore;
  void *FuncTableEntry;
  unsigned __int64 Params[4];
  int Far;
  int Virtual;
  unsigned __int64 Reserved[3];
  _KDHELP64 KdHelp;
};


struct _CERT_BASIC_CONSTRAINTS_INFO
{
  _CRYPT_BIT_BLOB SubjectType;
  int fPathLenConstraint;
  unsigned int dwPathLenConstraint;
  unsigned int cSubtreesConstraint;
  _CRYPTOAPI_BLOB *rgSubtreesConstraint;
};


struct tagHELPWININFOW
{
  int wStructSize;
  int x;
  int y;
  int dx;
  int dy;
  int wMax;
  unsigned __int16 rgchMember[2];
};


struct _numberfmtA
{
  unsigned int NumDigits;
  unsigned int LeadingZero;
  unsigned int Grouping;
  char *lpDecimalSep;
  char *lpThousandSep;
  unsigned int NegativeOrder;
};


struct _CERT_STORE_PROV_FIND_INFO
{
  unsigned int cbSize;
  unsigned int dwMsgAndCertEncodingType;
  unsigned int dwFindFlags;
  unsigned int dwFindType;
  const void *pvFindPara;
};


struct _WSAServiceClassInfoW
{
  _GUID *lpServiceClassId;
  unsigned __int16 *lpszServiceClassName;
  unsigned int dwCount;
  _WSANSClassInfoW *lpClassInfos;
};


struct tagHANDLETABLE
{
  void *objectHandle[1];
};


struct tagSOUNDSENTRYA
{
  unsigned int cbSize;
  unsigned int dwFlags;
  unsigned int iFSTextEffect;
  unsigned int iFSTextEffectMSec;
  unsigned int iFSTextEffectColorBits;
  unsigned int iFSGrafEffect;
  unsigned int iFSGrafEffectMSec;
  unsigned int iFSGrafEffectColor;
  unsigned int iWindowsEffect;
  unsigned int iWindowsEffectMSec;
  char *lpszWindowsEffectDLL;
  unsigned int iWindowsEffectOrdinal;
};


struct _IMAGE_RESOURCE_DATA_ENTRY
{
  unsigned int OffsetToData;
  unsigned int Size;
  unsigned int CodePage;
  unsigned int Reserved;
};


struct _COMMTIMEOUTS
{
  unsigned int ReadIntervalTimeout;
  unsigned int ReadTotalTimeoutMultiplier;
  unsigned int ReadTotalTimeoutConstant;
  unsigned int WriteTotalTimeoutMultiplier;
  unsigned int WriteTotalTimeoutConstant;
};


struct _SYSTEM_ALARM_CALLBACK_OBJECT_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int Flags;
  _GUID ObjectType;
  _GUID InheritedObjectType;
  unsigned int SidStart;
};


struct _EXIT_PROCESS_DEBUG_INFO
{
  unsigned int dwExitCode;
};


struct _CMC_ADD_ATTRIBUTES_INFO
{
  unsigned int dwCmcDataReference;
  unsigned int cCertReference;
  unsigned int *rgdwCertReference;
  unsigned int cAttribute;
  _CRYPT_ATTRIBUTE *rgAttribute;
};


struct _SOURCEFILE
{
  unsigned __int64 ModBase;
  char *FileName;
};


struct _ImageArchitectureEntry
{
  unsigned int FixupInstRVA;
  unsigned int NewInst;
};


union $4CFA15F5CE489CDF0BD78DFB308FEF36
{
  unsigned __int16 Ordinal;
  unsigned __int16 Hint;
};


struct IMPORT_OBJECT_HEADER
{
  unsigned __int16 Sig1;
  unsigned __int16 Sig2;
  unsigned __int16 Version;
  unsigned __int16 Machine;
  unsigned int TimeDateStamp;
  unsigned int SizeOfData;
  $4CFA15F5CE489CDF0BD78DFB308FEF36 ___u6;
  __int16 _bf18;
};


struct tagMSGBOXPARAMSW
{
  unsigned int cbSize;
  HWND__ *hwndOwner;
  HINSTANCE__ *hInstance;
  const unsigned __int16 *lpszText;
  const unsigned __int16 *lpszCaption;
  unsigned int dwStyle;
  const unsigned __int16 *lpszIcon;
  unsigned int dwContextHelpId;
  void (__stdcall *lpfnMsgBoxCallback)(tagHELPINFO *);
  unsigned int dwLanguageId;
};


struct _IMAGEHLP_DEFERRED_SYMBOL_LOAD64
{
  unsigned int SizeOfStruct;
  unsigned __int64 BaseOfImage;
  unsigned int CheckSum;
  unsigned int TimeDateStamp;
  char FileName[260];
  char Reparse;
  void *hFile;
  unsigned int Flags;
};


struct _CRYPT_TIME_STAMP_REQUEST_INFO
{
  char *pszTimeStampAlgorithm;
  char *pszContentType;
  _CRYPTOAPI_BLOB Content;
  unsigned int cAttribute;
  _CRYPT_ATTRIBUTE *rgAttribute;
};


struct tagMSG
{
  HWND__ *hwnd;
  unsigned int message;
  unsigned int wParam;
  int lParam;
  unsigned int time;
  tagPOINT pt;
};


struct _WSAServiceClassInfoA
{
  _GUID *lpServiceClassId;
  char *lpszServiceClassName;
  unsigned int dwCount;
  _WSANSClassInfoA *lpClassInfos;
};


struct _CERT_AUTHORITY_KEY_ID2_INFO
{
  _CRYPTOAPI_BLOB KeyId;
  _CERT_ALT_NAME_INFO AuthorityCertIssuer;
  _CRYPTOAPI_BLOB AuthorityCertSerialNumber;
};


struct tagLOGPALETTE
{
  unsigned __int16 palVersion;
  unsigned __int16 palNumEntries;
  tagPALETTEENTRY palPalEntry[1];
};


struct tagNONCLIENTMETRICSA
{
  unsigned int cbSize;
  int iBorderWidth;
  int iScrollWidth;
  int iScrollHeight;
  int iCaptionWidth;
  int iCaptionHeight;
  tagLOGFONTA lfCaptionFont;
  int iSmCaptionWidth;
  int iSmCaptionHeight;
  tagLOGFONTA lfSmCaptionFont;
  int iMenuWidth;
  int iMenuHeight;
  tagLOGFONTA lfMenuFont;
  tagLOGFONTA lfStatusFont;
  tagLOGFONTA lfMessageFont;
};


struct tagCREATESTRUCTW
{
  void *lpCreateParams;
  HINSTANCE__ *hInstance;
  HMENU__ *hMenu;
  HWND__ *hwndParent;
  int cy;
  int cx;
  int y;
  int x;
  int style;
  const unsigned __int16 *lpszName;
  const unsigned __int16 *lpszClass;
  unsigned int dwExStyle;
};


struct tagCBT_CREATEWNDW
{
  tagCREATESTRUCTW *lpcs;
  HWND__ *hwndInsertAfter;
};


struct tagACTCTX_SECTION_KEYED_DATA_2600
{
  unsigned int cbSize;
  unsigned int ulDataFormatVersion;
  void *lpData;
  unsigned int ulLength;
  void *lpSectionGlobalData;
  unsigned int ulSectionGlobalDataLength;
  void *lpSectionBase;
  unsigned int ulSectionTotalLength;
  void *hActCtx;
  unsigned int ulAssemblyRosterIndex;
};


struct FLASHWINFO
{
  unsigned int cbSize;
  HWND__ *hwnd;
  unsigned int dwFlags;
  unsigned int uCount;
  unsigned int dwTimeout;
};


struct _CRYPT_OBJID_TABLE
{
  unsigned int dwAlgId;
  const char *pszObjId;
};


struct _MODEMDEVCAPS
{
  unsigned int dwActualSize;
  unsigned int dwRequiredSize;
  unsigned int dwDevSpecificOffset;
  unsigned int dwDevSpecificSize;
  unsigned int dwModemProviderVersion;
  unsigned int dwModemManufacturerOffset;
  unsigned int dwModemManufacturerSize;
  unsigned int dwModemModelOffset;
  unsigned int dwModemModelSize;
  unsigned int dwModemVersionOffset;
  unsigned int dwModemVersionSize;
  unsigned int dwDialOptions;
  unsigned int dwCallSetupFailTimer;
  unsigned int dwInactivityTimeout;
  unsigned int dwSpeakerVolume;
  unsigned int dwSpeakerMode;
  unsigned int dwModemOptions;
  unsigned int dwMaxDTERate;
  unsigned int dwMaxDCERate;
  char abVariablePortion[1];
};


struct _WIN_TRUST_SUBJECT_FILE
{
  void *hFile;
  const unsigned __int16 *lpPath;
};


struct _CERT_AUTHORITY_KEY_ID_INFO
{
  _CRYPTOAPI_BLOB KeyId;
  _CRYPTOAPI_BLOB CertIssuer;
  _CRYPTOAPI_BLOB CertSerialNumber;
};


struct _CERT_PAIR
{
  _CRYPTOAPI_BLOB Forward;
  _CRYPTOAPI_BLOB Reverse;
};


struct _MINIDUMP_USER_STREAM_INFORMATION
{
  unsigned int UserStreamCount;
  _MINIDUMP_USER_STREAM *UserStreamArray;
};


struct _NT_TIB
{
  struct _EXCEPTION_REGISTRATION_RECORD *ExceptionList;
  void *StackBase;
  void *StackLimit;
  void *SubSystemTib;
  $7A727655067EA29DD1B3C3F7D79CBFD1 ___u4;
  void *ArbitraryUserPointer;
  _NT_TIB *Self;
};


union $7A727655067EA29DD1B3C3F7D79CBFD1
{
  void *FiberData;
  unsigned int Version;
};


struct tagWINDOWPLACEMENT
{
  unsigned int length;
  unsigned int flags;
  unsigned int showCmd;
  tagPOINT ptMinPosition;
  tagPOINT ptMaxPosition;
  tagRECT rcNormalPosition;
};


struct _SERVICE_STATUS
{
  unsigned int dwServiceType;
  unsigned int dwCurrentState;
  unsigned int dwControlsAccepted;
  unsigned int dwWin32ExitCode;
  unsigned int dwServiceSpecificExitCode;
  unsigned int dwCheckPoint;
  unsigned int dwWaitHint;
};


struct _ENUM_SERVICE_STATUSW
{
  unsigned __int16 *lpServiceName;
  unsigned __int16 *lpDisplayName;
  _SERVICE_STATUS ServiceStatus;
};


struct value_entW
{
  unsigned __int16 *ve_valuename;
  unsigned int ve_valuelen;
  unsigned int ve_valueptr;
  unsigned int ve_type;
};


struct _CROSS_CERT_DIST_POINTS_INFO
{
  unsigned int dwSyncDeltaTime;
  unsigned int cDistPoint;
  _CERT_ALT_NAME_INFO *rgDistPoint;
};


struct _IMAGEHLP_LINE64
{
  unsigned int SizeOfStruct;
  void *Key;
  unsigned int LineNumber;
  char *FileName;
  unsigned __int64 Address;
};


struct _PACKEDEVENTINFO
{
  unsigned int ulSize;
  unsigned int ulNumEventsForLogFile;
  unsigned int ulOffsets[];
};


struct _MEMORYSTATUSEX
{
  unsigned int dwLength;
  unsigned int dwMemoryLoad;
  unsigned __int64 ullTotalPhys;
  unsigned __int64 ullAvailPhys;
  unsigned __int64 ullTotalPageFile;
  unsigned __int64 ullAvailPageFile;
  unsigned __int64 ullTotalVirtual;
  unsigned __int64 ullAvailVirtual;
  unsigned __int64 ullAvailExtendedVirtual;
};


struct sockproto
{
  unsigned __int16 sp_family;
  unsigned __int16 sp_protocol;
};


struct _PSINJECTDATA
{
  unsigned int DataBytes;
  unsigned __int16 InjectionPoint;
  unsigned __int16 PageNumber;
};


struct tagMENUITEMINFOW
{
  unsigned int cbSize;
  unsigned int fMask;
  unsigned int fType;
  unsigned int fState;
  unsigned int wID;
  HMENU__ *hSubMenu;
  HBITMAP__ *hbmpChecked;
  HBITMAP__ *hbmpUnchecked;
  unsigned int dwItemData;
  unsigned __int16 *dwTypeData;
  unsigned int cch;
  HBITMAP__ *hbmpItem;
};


struct tagGCP_RESULTSA
{
  unsigned int lStructSize;
  char *lpOutString;
  unsigned int *lpOrder;
  int *lpDx;
  int *lpCaretPos;
  char *lpClass;
  unsigned __int16 *lpGlyphs;
  unsigned int nGlyphs;
  int nMaxFit;
};


struct API_VERSION
{
  unsigned __int16 MajorVersion;
  unsigned __int16 MinorVersion;
  unsigned __int16 Revision;
  unsigned __int16 Reserved;
};


struct HTASK__
{
  int unused;
};


struct tagEMRFORMAT
{
  unsigned int dSignature;
  unsigned int nVersion;
  unsigned int cbData;
  unsigned int offData;
};


struct _CRL_DIST_POINT
{
  _CRL_DIST_POINT_NAME DistPointName;
  _CRYPT_BIT_BLOB ReasonFlags;
  _CERT_ALT_NAME_INFO CRLIssuer;
};


struct _CRL_DIST_POINTS_INFO
{
  unsigned int cDistPoint;
  _CRL_DIST_POINT *rgDistPoint;
};


struct tagMETARECORD
{
  unsigned int rdSize;
  unsigned __int16 rdFunction;
  unsigned __int16 rdParm[1];
};


struct _MODULE_TYPE_INFO
{
  unsigned __int16 dataLength;
  unsigned __int16 leaf;
  char data[1];
};


struct _GENERIC_MAPPING
{
  unsigned int GenericRead;
  unsigned int GenericWrite;
  unsigned int GenericExecute;
  unsigned int GenericAll;
};


struct _heapinfo
{
  int *_pentry;
  unsigned int _size;
  int _useflag;
};


struct _SC_ACTION
{
  _SC_ACTION_TYPE Type;
  unsigned int Delay;
};


struct _SERVICE_FAILURE_ACTIONSA
{
  unsigned int dwResetPeriod;
  char *lpRebootMsg;
  char *lpCommand;
  unsigned int cActions;
  _SC_ACTION *lpsaActions;
};


struct HIMC__
{
  int unused;
};


struct _CRYPT_VERIFY_MESSAGE_PARA
{
  unsigned int cbSize;
  unsigned int dwMsgAndCertEncodingType;
  unsigned int hCryptProv;
  _CERT_CONTEXT *(__stdcall *pfnGetSignerCertificate)(void *, unsigned int, _CERT_INFO *, void *);
  void *pvGetArg;
};


struct _CMSG_SIGNER_ENCODE_INFO
{
  unsigned int cbSize;
  _CERT_INFO *pCertInfo;
  unsigned int hCryptProv;
  unsigned int dwKeySpec;
  _CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm;
  void *pvHashAuxInfo;
  unsigned int cAuthAttr;
  _CRYPT_ATTRIBUTE *rgAuthAttr;
  unsigned int cUnauthAttr;
  _CRYPT_ATTRIBUTE *rgUnauthAttr;
};


struct _CMSG_SIGNED_ENCODE_INFO
{
  unsigned int cbSize;
  unsigned int cSigners;
  _CMSG_SIGNER_ENCODE_INFO *rgSigners;
  unsigned int cCertEncoded;
  _CRYPTOAPI_BLOB *rgCertEncoded;
  unsigned int cCrlEncoded;
  _CRYPTOAPI_BLOB *rgCrlEncoded;
};


struct tagEMREXTCREATEPEN
{
  tagEMR emr;
  unsigned int ihPen;
  unsigned int offBmi;
  unsigned int cbBmi;
  unsigned int offBits;
  unsigned int cbBits;
  tagEXTLOGPEN elp;
};


struct _IMAGEHLP_LINE
{
  unsigned int SizeOfStruct;
  void *Key;
  unsigned int LineNumber;
  char *FileName;
  unsigned int Address;
};


union $66A2FC5ED47CB5912809650DAB14E256
{
  unsigned int VirtualAddress;
  unsigned int RelocCount;
};


struct _IMAGE_RELOCATION
{
  $66A2FC5ED47CB5912809650DAB14E256 ___u0;
  unsigned int SymbolTableIndex;
  unsigned __int16 Type;
};


struct _WIN_TRUST_ACTDATA_SUBJECT_ONLY
{
  _GUID *SubjectType;
  void *Subject;
};


struct tagWNDCLASSW
{
  unsigned int style;
  int (__stdcall *lpfnWndProc)(HWND__ *, unsigned int, unsigned int, int);
  int cbClsExtra;
  int cbWndExtra;
  HINSTANCE__ *hInstance;
  HICON__ *hIcon;
  HICON__ *hCursor;
  HBRUSH__ *hbrBackground;
  const unsigned __int16 *lpszMenuName;
  const unsigned __int16 *lpszClassName;
};


struct _QUERY_SERVICE_LOCK_STATUSW
{
  unsigned int fIsLocked;
  unsigned __int16 *lpLockOwner;
  unsigned int dwLockDuration;
};


struct _MINIDUMP_USER_RECORD
{
  unsigned int Type;
  _MINIDUMP_LOCATION_DESCRIPTOR Memory;
};


struct _MOUSE_EVENT_RECORD
{
  _COORD dwMousePosition;
  unsigned int dwButtonState;
  unsigned int dwControlKeyState;
  unsigned int dwEventFlags;
};


struct tagLOCALESIGNATURE
{
  unsigned int lsUsb[4];
  unsigned int lsCsbDefault[2];
  unsigned int lsCsbSupported[2];
};


struct _CONNECTDLGSTRUCTW
{
  unsigned int cbStructure;
  HWND__ *hwndOwner;
  _NETRESOURCEW *lpConnRes;
  unsigned int dwFlags;
  unsigned int dwDevNum;
};


struct tagWINDOWPOS
{
  HWND__ *hwnd;
  HWND__ *hwndInsertAfter;
  int x;
  int y;
  int cx;
  int cy;
  unsigned int flags;
};


struct tagNCCALCSIZE_PARAMS
{
  tagRECT rgrc[3];
  tagWINDOWPOS *lppos;
};


struct _WSACOMPLETION::__unnamed::__unnamed
{
  HWND__ *hWnd;
  unsigned int uMsg;
  unsigned int context;
};


union _WSACOMPLETION::__unnamed
{
  _WSACOMPLETION::__unnamed::__unnamed WindowMessage;
  _WSACOMPLETION::__unnamed::__unnamed Event;
  _WSACOMPLETION::__unnamed::__unnamed Apc;
  _WSACOMPLETION::__unnamed::__unnamed Port;
};


struct _WSACOMPLETION
{
  _WSACOMPLETIONTYPE Type;
  _WSACOMPLETION::__unnamed Parameters;
};


struct _IMAGE_SEPARATE_DEBUG_HEADER
{
  unsigned __int16 Signature;
  unsigned __int16 Flags;
  unsigned __int16 Machine;
  unsigned __int16 Characteristics;
  unsigned int TimeDateStamp;
  unsigned int CheckSum;
  unsigned int ImageBase;
  unsigned int SizeOfImage;
  unsigned int NumberOfSections;
  unsigned int ExportedNamesSize;
  unsigned int DebugDirectorySize;
  unsigned int SectionAlignment;
  unsigned int Reserved[2];
};


struct tagCOMPAREITEMSTRUCT
{
  unsigned int CtlType;
  unsigned int CtlID;
  HWND__ *hwndItem;
  unsigned int itemID1;
  unsigned int itemData1;
  unsigned int itemID2;
  unsigned int itemData2;
  unsigned int dwLocaleId;
};


struct _CERT_CHAIN_PARA
{
  unsigned int cbSize;
  _CERT_USAGE_MATCH RequestedUsage;
};


struct _ENUM_SERVICE_STATUSA
{
  char *lpServiceName;
  char *lpDisplayName;
  _SERVICE_STATUS ServiceStatus;
};


struct tagEMRRESTOREDC
{
  tagEMR emr;
  int iRelative;
};


struct _MESSAGE_RESOURCE_DATA
{
  unsigned int NumberOfBlocks;
  _MESSAGE_RESOURCE_BLOCK Blocks[1];
};


struct _cpinfoexW
{
  unsigned int MaxCharSize;
  char DefaultChar[2];
  char LeadByte[12];
  unsigned __int16 UnicodeDefaultChar;
  unsigned int CodePage;
  unsigned __int16 CodePageName[260];
};


struct tagIMECHARPOSITION
{
  unsigned int dwSize;
  unsigned int dwCharPos;
  tagPOINT pt;
  unsigned int cLineHeight;
  tagRECT rcDocument;
};


struct __wfinddata64_t
{
  unsigned int attrib;
  __int64 time_create;
  __int64 time_access;
  __int64 time_write;
  __int64 size;
  wchar_t name[260];
};


struct $3A7B6FA2F821B9E5D08E8642C189F28F
{
  _SINGLE_LIST_ENTRY Next;
  unsigned __int16 Depth;
  unsigned __int16 Sequence;
};


union _SLIST_HEADER
{
  unsigned __int64 Alignment;
  $3A7B6FA2F821B9E5D08E8642C189F28F _s1;
};


struct _SYSTEMTIME
{
  unsigned __int16 wYear;
  unsigned __int16 wMonth;
  unsigned __int16 wDayOfWeek;
  unsigned __int16 wDay;
  unsigned __int16 wHour;
  unsigned __int16 wMinute;
  unsigned __int16 wSecond;
  unsigned __int16 wMilliseconds;
};


struct _UNIVERSAL_NAME_INFOW
{
  unsigned __int16 *lpUniversalName;
};


struct _TAPE_WRITE_MARKS
{
  unsigned int Type;
  unsigned int Count;
  char Immediate;
};


struct tagSTYLEBUFA
{
  unsigned int dwStyle;
  char szDescription[32];
};


struct tagCURSORINFO
{
  unsigned int cbSize;
  unsigned int flags;
  HICON__ *hCursor;
  tagPOINT ptScreenPos;
};


struct value_entA
{
  char *ve_valuename;
  unsigned int ve_valuelen;
  unsigned int ve_valueptr;
  unsigned int ve_type;
};


struct tagENUMLOGFONTEXW
{
  tagLOGFONTW elfLogFont;
  unsigned __int16 elfFullName[64];
  unsigned __int16 elfStyle[32];
  unsigned __int16 elfScript[32];
};


struct tagENUMLOGFONTEXDVW
{
  tagENUMLOGFONTEXW elfEnumLogfontEx;
  tagDESIGNVECTOR elfDesignVector;
};


struct _IO_COUNTERS
{
  unsigned __int64 ReadOperationCount;
  unsigned __int64 WriteOperationCount;
  unsigned __int64 OtherOperationCount;
  unsigned __int64 ReadTransferCount;
  unsigned __int64 WriteTransferCount;
  unsigned __int64 OtherTransferCount;
};


struct _JOBOBJECT_EXTENDED_LIMIT_INFORMATION
{
  _JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
  _IO_COUNTERS IoInfo;
  unsigned int ProcessMemoryLimit;
  unsigned int JobMemoryLimit;
  unsigned int PeakProcessMemoryUsed;
  unsigned int PeakJobMemoryUsed;
};


struct _MINIDUMP_MODULE_LIST
{
  unsigned int NumberOfModules;
  _MINIDUMP_MODULE Modules[];
};


struct _MINIDUMP_HANDLE_DESCRIPTOR
{
  unsigned __int64 Handle;
  unsigned int TypeNameRva;
  unsigned int ObjectNameRva;
  unsigned int Attributes;
  unsigned int GrantedAccess;
  unsigned int HandleCount;
  unsigned int PointerCount;
};


struct _MEMORYSTATUS
{
  unsigned int dwLength;
  unsigned int dwMemoryLoad;
  unsigned int dwTotalPhys;
  unsigned int dwAvailPhys;
  unsigned int dwTotalPageFile;
  unsigned int dwAvailPageFile;
  unsigned int dwTotalVirtual;
  unsigned int dwAvailVirtual;
};


struct _WGLSWAP
{
  HDC__ *hdc;
  unsigned int uiFlags;
};


struct _CERT_NAME_CONSTRAINTS_INFO
{
  unsigned int cPermittedSubtree;
  _CERT_GENERAL_SUBTREE *rgPermittedSubtree;
  unsigned int cExcludedSubtree;
  _CERT_GENERAL_SUBTREE *rgExcludedSubtree;
};


struct tagCHARSETINFO
{
  unsigned int ciCharset;
  unsigned int ciACP;
  tagFONTSIGNATURE fs;
};


struct tagTTPOLYGONHEADER
{
  unsigned int cb;
  unsigned int dwType;
  tagPOINTFX pfxStart;
};


struct _MODLOAD_DATA
{
  unsigned int ssize;
  unsigned int ssig;
  void *data;
  unsigned int size;
  unsigned int flags;
};


struct _IMAGE_ARCHIVE_MEMBER_HEADER
{
  char Name[16];
  char Date[12];
  char UserID[6];
  char GroupID[6];
  char Mode[8];
  char Size[10];
  char EndHeader[2];
};


struct _CERT_DSS_PARAMETERS
{
  _CRYPTOAPI_BLOB p;
  _CRYPTOAPI_BLOB q;
  _CRYPTOAPI_BLOB g;
};


struct _IMAGEHLP_DUPLICATE_SYMBOL64
{
  unsigned int SizeOfStruct;
  unsigned int NumberOfDups;
  _IMAGEHLP_SYMBOL64 *Symbol;
  unsigned int SelectedSymbol;
};


struct _MINIDUMP_THREAD_LIST
{
  unsigned int NumberOfThreads;
  _MINIDUMP_THREAD Threads[];
};


struct _CERT_CHAIN
{
  unsigned int cCerts;
  _CRYPTOAPI_BLOB *certs;
  _CRYPT_KEY_PROV_INFO keyLocatorInfo;
};


struct _IMAGEHLP_DUPLICATE_SYMBOL
{
  unsigned int SizeOfStruct;
  unsigned int NumberOfDups;
  _IMAGEHLP_SYMBOL *Symbol;
  unsigned int SelectedSymbol;
};


struct IMAGE_COR20_HEADER
{
  unsigned int cb;
  unsigned __int16 MajorRuntimeVersion;
  unsigned __int16 MinorRuntimeVersion;
  _IMAGE_DATA_DIRECTORY MetaData;
  unsigned int Flags;
  unsigned int EntryPointToken;
  _IMAGE_DATA_DIRECTORY Resources;
  _IMAGE_DATA_DIRECTORY StrongNameSignature;
  _IMAGE_DATA_DIRECTORY CodeManagerTable;
  _IMAGE_DATA_DIRECTORY VTableFixups;
  _IMAGE_DATA_DIRECTORY ExportAddressTableJumps;
  _IMAGE_DATA_DIRECTORY ManagedNativeHeader;
};


struct _IMAGE_EXPORT_DIRECTORY
{
  unsigned int Characteristics;
  unsigned int TimeDateStamp;
  unsigned __int16 MajorVersion;
  unsigned __int16 MinorVersion;
  unsigned int Name;
  unsigned int Base;
  unsigned int NumberOfFunctions;
  unsigned int NumberOfNames;
  unsigned int AddressOfFunctions;
  unsigned int AddressOfNames;
  unsigned int AddressOfNameOrdinals;
};


struct tagNEWTEXTMETRICW
{
  int tmHeight;
  int tmAscent;
  int tmDescent;
  int tmInternalLeading;
  int tmExternalLeading;
  int tmAveCharWidth;
  int tmMaxCharWidth;
  int tmWeight;
  int tmOverhang;
  int tmDigitizedAspectX;
  int tmDigitizedAspectY;
  unsigned __int16 tmFirstChar;
  unsigned __int16 tmLastChar;
  unsigned __int16 tmDefaultChar;
  unsigned __int16 tmBreakChar;
  char tmItalic;
  char tmUnderlined;
  char tmStruckOut;
  char tmPitchAndFamily;
  char tmCharSet;
  unsigned int ntmFlags;
  unsigned int ntmSizeEM;
  unsigned int ntmCellHeight;
  unsigned int ntmAvgWidth;
};


struct tagNEWTEXTMETRICEXW
{
  tagNEWTEXTMETRICW ntmTm;
  tagFONTSIGNATURE ntmFontSig;
};


struct tagENUMTEXTMETRICW
{
  tagNEWTEXTMETRICEXW etmNewTextMetricEx;
  tagAXESLISTW etmAxesList;
};


struct tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA
{
  void *lpInformation;
  void *lpSectionBase;
  unsigned int ulSectionLength;
  void *lpSectionGlobalDataBase;
  unsigned int ulSectionGlobalDataLength;
};


struct tagACTCTX_SECTION_KEYED_DATA
{
  unsigned int cbSize;
  unsigned int ulDataFormatVersion;
  void *lpData;
  unsigned int ulLength;
  void *lpSectionGlobalData;
  unsigned int ulSectionGlobalDataLength;
  void *lpSectionBase;
  unsigned int ulSectionTotalLength;
  void *hActCtx;
  unsigned int ulAssemblyRosterIndex;
  unsigned int ulFlags;
  tagACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA AssemblyMetadata;
};


struct _CRYPT_KEY_SIGN_MESSAGE_PARA
{
  unsigned int cbSize;
  unsigned int dwMsgAndCertEncodingType;
  unsigned int hCryptProv;
  unsigned int dwKeySpec;
  _CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm;
  void *pvHashAuxInfo;
  _CRYPT_ALGORITHM_IDENTIFIER PubKeyAlgorithm;
};


struct tagEMRPLGBLT
{
  tagEMR emr;
  _RECTL rclBounds;
  _POINTL aptlDest[3];
  int xSrc;
  int ySrc;
  int cxSrc;
  int cySrc;
  tagXFORM xformSrc;
  unsigned int crBkColorSrc;
  unsigned int iUsageSrc;
  unsigned int offBmiSrc;
  unsigned int cbBmiSrc;
  unsigned int offBitsSrc;
  unsigned int cbBitsSrc;
  int xMask;
  int yMask;
  unsigned int iUsageMask;
  unsigned int offBmiMask;
  unsigned int cbBmiMask;
  unsigned int offBitsMask;
  unsigned int cbBitsMask;
};


struct _LOAD_DLL_DEBUG_INFO
{
  void *hFile;
  void *lpBaseOfDll;
  unsigned int dwDebugInfoFileOffset;
  unsigned int nDebugInfoSize;
  void *lpImageName;
  unsigned __int16 fUnicode;
};


struct _IMAGE_RUNTIME_FUNCTION_ENTRY
{
  unsigned int BeginAddress;
  unsigned int EndAddress;
  unsigned int UnwindInfoAddress;
};


struct _CMSG_HASHED_ENCODE_INFO
{
  unsigned int cbSize;
  unsigned int hCryptProv;
  _CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm;
  void *pvHashAuxInfo;
};


struct _CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA
{
  unsigned int cbSize;
  unsigned int hCryptProv;
  unsigned int dwSignerIndex;
  unsigned int dwSignerType;
  void *pvSigner;
};


struct tagEMRCREATEMONOBRUSH
{
  tagEMR emr;
  unsigned int ihBrush;
  unsigned int iUsage;
  unsigned int offBmi;
  unsigned int cbBmi;
  unsigned int offBits;
  unsigned int cbBits;
};


union _FILE_SEGMENT_ELEMENT
{
  void *Buffer;
  unsigned __int64 Alignment;
};


struct _div_t
{
  int quot;
  int rem;
};


struct _GLYPHMETRICS
{
  unsigned int gmBlackBoxX;
  unsigned int gmBlackBoxY;
  tagPOINT gmptGlyphOrigin;
  __int16 gmCellIncX;
  __int16 gmCellIncY;
};


struct CNoMemoryObject
{
  char dummy[1];
};


struct CMemory::CInit
{
  char dummy[1];
};


struct CMemory::tagEntry
{
  int sizeFront;
  CMemory::tagEntry *pEntryNext;
  CMemory::tagEntry *pEntryPrev;
};


struct CMemory::tagListHead
{
  CMemory::tagEntry *pEntryNext;
  CMemory::tagEntry *pEntryPrev;
};


struct CMemory::tagEntryEnd
{
  int sizeBack;
};


struct CMemory::tagGroup
{
  int cntEntries;
  CMemory::tagListHead listHead[64];
};


struct CMemory::tagRegion
{
  int indGroupUse;
  char cntRegionSize[64];
  unsigned int bitvGroupHi[32];
  unsigned int bitvGroupLo[32];
  CMemory::tagGroup grpHeadList[32];
};


struct CMemory::tagHeader
{
  unsigned int bitvEntryHi;
  unsigned int bitvEntryLo;
  unsigned int bitvCommit;
  void *pHeapData;
  CMemory::tagRegion *pRegion;
};


union $D8904DF859DD7E93215AA3BA88355D7A
{
  CNoMemoryObject baseclass_0;
  void *_crtheap;
};


struct CMemory
{
  $D8904DF859DD7E93215AA3BA88355D7A ___u0;
  unsigned int __sbh_threshold;
  CMemory::tagHeader *__sbh_pHeaderList;
  CMemory::tagHeader *__sbh_pHeaderScan;
  int __sbh_sizeHeaderList;
  int __sbh_cntHeaderList;
  CMemory::tagHeader *__sbh_pHeaderDefer;
  int __sbh_indGroupDefer;
  _RTL_CRITICAL_SECTION _lock;
};


struct _JOB_SET_ARRAY
{
  void *JobHandle;
  unsigned int MemberLevel;
  unsigned int Flags;
};


struct _JOBOBJECT_BASIC_ACCOUNTING_INFORMATION
{
  _LARGE_INTEGER TotalUserTime;
  _LARGE_INTEGER TotalKernelTime;
  _LARGE_INTEGER ThisPeriodTotalUserTime;
  _LARGE_INTEGER ThisPeriodTotalKernelTime;
  unsigned int TotalPageFaultCount;
  unsigned int TotalProcesses;
  unsigned int ActiveProcesses;
  unsigned int TotalTerminatedProcesses;
};


struct _JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION
{
  _JOBOBJECT_BASIC_ACCOUNTING_INFORMATION BasicInfo;
  _IO_COUNTERS IoInfo;
};


struct _MINIDUMP_MISC_INFO
{
  unsigned int SizeOfInfo;
  unsigned int Flags1;
  unsigned int ProcessId;
  unsigned int ProcessCreateTime;
  unsigned int ProcessUserTime;
  unsigned int ProcessKernelTime;
};


struct tagEMRSETMITERLIMIT
{
  tagEMR emr;
  float eMiterLimit;
};


struct tagEMRCREATEBRUSHINDIRECT
{
  tagEMR emr;
  unsigned int ihBrush;
  tagLOGBRUSH32 lb;
};


struct _CERT_DH_PARAMETERS
{
  _CRYPTOAPI_BLOB p;
  _CRYPTOAPI_BLOB g;
};


struct _IMAGEHLP_MODULE64W
{
  unsigned int SizeOfStruct;
  unsigned __int64 BaseOfImage;
  unsigned int ImageSize;
  unsigned int TimeDateStamp;
  unsigned int CheckSum;
  unsigned int NumSyms;
  SYM_TYPE SymType;
  unsigned __int16 ModuleName[32];
  unsigned __int16 ImageName[256];
  unsigned __int16 LoadedImageName[256];
};


struct _ACTIVATION_CONTEXT_DETAILED_INFORMATION
{
  unsigned int dwFlags;
  unsigned int ulFormatVersion;
  unsigned int ulAssemblyCount;
  unsigned int ulRootManifestPathType;
  unsigned int ulRootManifestPathChars;
  unsigned int ulRootConfigurationPathType;
  unsigned int ulRootConfigurationPathChars;
  unsigned int ulAppDirPathType;
  unsigned int ulAppDirPathChars;
  const unsigned __int16 *lpRootManifestPath;
  const unsigned __int16 *lpRootConfigurationPath;
  const unsigned __int16 *lpAppDirPath;
};


struct _CREATE_THREAD_DEBUG_INFO
{
  void *hThread;
  void *lpThreadLocalBase;
  unsigned int (__stdcall *lpStartAddress)(void *);
};


union _DEBUG_EVENT::__unnamed
{
  _EXCEPTION_DEBUG_INFO Exception;
  _CREATE_THREAD_DEBUG_INFO CreateThread;
  _CREATE_PROCESS_DEBUG_INFO CreateProcessInfo;
  _EXIT_THREAD_DEBUG_INFO ExitThread;
  _EXIT_PROCESS_DEBUG_INFO ExitProcess;
  _LOAD_DLL_DEBUG_INFO LoadDll;
  _UNLOAD_DLL_DEBUG_INFO UnloadDll;
  _OUTPUT_DEBUG_STRING_INFO DebugString;
  _RIP_INFO RipInfo;
};


struct _DEBUG_EVENT
{
  unsigned int dwDebugEventCode;
  unsigned int dwProcessId;
  unsigned int dwThreadId;
  _DEBUG_EVENT::__unnamed u;
};


struct _SECURITY_DESCRIPTOR_RELATIVE
{
  char Revision;
  char Sbz1;
  unsigned __int16 Control;
  unsigned int Owner;
  unsigned int Group;
  unsigned int Sacl;
  unsigned int Dacl;
};


struct _MINIDUMP_MEMORY_LIST
{
  unsigned int NumberOfMemoryRanges;
  _MINIDUMP_MEMORY_DESCRIPTOR MemoryRanges[];
};


struct _CERT_REVOCATION_STATUS
{
  unsigned int cbSize;
  unsigned int dwIndex;
  unsigned int dwError;
  unsigned int dwReason;
  int fHasFreshnessTime;
  unsigned int dwFreshnessTime;
};


struct _TOKEN_STATISTICS
{
  _LUID TokenId;
  _LUID AuthenticationId;
  _LARGE_INTEGER ExpirationTime;
  _TOKEN_TYPE TokenType;
  _SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
  unsigned int DynamicCharged;
  unsigned int DynamicAvailable;
  unsigned int GroupCount;
  unsigned int PrivilegeCount;
  _LUID ModifiedId;
};


struct _PRIVILEGE_SET
{
  unsigned int PrivilegeCount;
  unsigned int Control;
  _LUID_AND_ATTRIBUTES Privilege[1];
};


struct _TAPE_GET_POSITION
{
  unsigned int Type;
  unsigned int Partition;
  _LARGE_INTEGER Offset;
};


struct _CERT_CHAIN_POLICY_STATUS
{
  unsigned int cbSize;
  unsigned int dwError;
  int lChainIndex;
  int lElementIndex;
  void *pvExtraPolicyStatus;
};


struct _CRYPT_PKCS8_EXPORT_PARAMS
{
  unsigned int hCryptProv;
  unsigned int dwKeySpec;
  char *pszPrivateKeyObjId;
  int (__stdcall *pEncryptPrivateKeyFunc)(_CRYPT_ALGORITHM_IDENTIFIER *, _CRYPTOAPI_BLOB *, char *, unsigned int *, void *);
  void *pVoidEncryptFunc;
};


struct tagMOUSEHOOKSTRUCTEX
{
  tagMOUSEHOOKSTRUCT baseclass_0;
  unsigned int mouseData;
};


struct _SPC_SP_OPUS_INFO
{
  const unsigned __int16 *pwszProgramName;
  SPC_LINK_ *pMoreInfo;
  SPC_LINK_ *pPublisherInfo;
};


struct tagCWPSTRUCT
{
  int lParam;
  unsigned int wParam;
  unsigned int message;
  HWND__ *hwnd;
};


struct tagALTTABINFO
{
  unsigned int cbSize;
  int cItems;
  int cColumns;
  int cRows;
  int iColFocus;
  int iRowFocus;
  int cxItem;
  int cyItem;
  tagPOINT ptStart;
};


struct _RSAPUBKEY
{
  unsigned int magic;
  unsigned int bitlen;
  unsigned int pubexp;
};


struct _IMAGE_TLS_DIRECTORY32
{
  unsigned int StartAddressOfRawData;
  unsigned int EndAddressOfRawData;
  unsigned int AddressOfIndex;
  unsigned int AddressOfCallBacks;
  unsigned int SizeOfZeroFill;
  unsigned int Characteristics;
};


struct tagEMRPOLYDRAW16
{
  tagEMR emr;
  _RECTL rclBounds;
  unsigned int cpts;
  tagPOINTS apts[1];
  char abTypes[1];
};


struct _GRADIENT_RECT
{
  unsigned int UpperLeft;
  unsigned int LowerRight;
};


struct _QOS_SHAPING_RATE
{
  QOS_OBJECT_HDR ObjectHdr;
  unsigned int ShapingRate;
};


struct _TAPE_ERASE
{
  unsigned int Type;
  char Immediate;
};


struct HRSRC__
{
  int unused;
};


struct _ACL_SIZE_INFORMATION
{
  unsigned int AceCount;
  unsigned int AclBytesInUse;
  unsigned int AclBytesFree;
};


struct _CMSG_SP3_COMPATIBLE_AUX_INFO
{
  unsigned int cbSize;
  unsigned int dwFlags;
};


struct tagEMRPOLYPOLYLINE16
{
  tagEMR emr;
  _RECTL rclBounds;
  unsigned int nPolys;
  unsigned int cpts;
  unsigned int aPolyCounts[1];
  tagPOINTS apts[1];
};


struct _CRYPT_PRIVATE_KEY_INFO
{
  unsigned int Version;
  _CRYPT_ALGORITHM_IDENTIFIER Algorithm;
  _CRYPTOAPI_BLOB PrivateKey;
  _CRYPT_ATTRIBUTES *pAttributes;
};


struct _MINIDUMP_DIRECTORY
{
  unsigned int StreamType;
  _MINIDUMP_LOCATION_DESCRIPTOR Location;
};


struct _LARGE_INTEGER::__unnamed
{
  unsigned int LowPart;
  int HighPart;
};


struct tagHW_PROFILE_INFOA
{
  unsigned int dwDockInfo;
  char szHwProfileGuid[39];
  char szHwProfileName[80];
};


struct _ENUM_SERVICE_STATUS_PROCESSW
{
  unsigned __int16 *lpServiceName;
  unsigned __int16 *lpDisplayName;
  _SERVICE_STATUS_PROCESS ServiceStatusProcess;
};


struct _CMSG_RC2_AUX_INFO
{
  unsigned int cbSize;
  unsigned int dwBitLen;
};


struct tagKERNINGPAIR
{
  unsigned __int16 wFirst;
  unsigned __int16 wSecond;
  int iKernAmount;
};


struct _ULARGE_INTEGER::__unnamed
{
  unsigned int LowPart;
  unsigned int HighPart;
};


struct $B950AFB169DC87688B328897744C612F
{
  unsigned int LowPart;
  unsigned int HighPart;
};


union _ULARGE_INTEGER
{
  $B950AFB169DC87688B328897744C612F _s0;
  _ULARGE_INTEGER::__unnamed u;
  unsigned __int64 QuadPart;
};


struct _SPC_PE_IMAGE_DATA
{
  _CRYPT_BIT_BLOB Flags;
  SPC_LINK_ *pFile;
};


struct tagEMRCREATEPEN
{
  tagEMR emr;
  unsigned int ihPen;
  tagLOGPEN lopn;
};


union _KEY_EVENT_RECORD::__unnamed
{
  unsigned __int16 UnicodeChar;
  char AsciiChar;
};


struct _KEY_EVENT_RECORD
{
  int bKeyDown;
  unsigned __int16 wRepeatCount;
  unsigned __int16 wVirtualKeyCode;
  unsigned __int16 wVirtualScanCode;
  _KEY_EVENT_RECORD::__unnamed uChar;
  unsigned int dwControlKeyState;
};


struct tagGLYPHSET
{
  unsigned int cbThis;
  unsigned int flAccel;
  unsigned int cGlyphsSupported;
  unsigned int cRanges;
  tagWCRANGE ranges[1];
};


struct _QUERY_SERVICE_LOCK_STATUSA
{
  unsigned int fIsLocked;
  char *lpLockOwner;
  unsigned int dwLockDuration;
};


struct _OBJECTID
{
  _GUID Lineage;
  unsigned int Uniquifier;
};


struct _SYSTEM_ALARM_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int SidStart;
};


struct IMAGE_LOAD_CONFIG_DIRECTORY64
{
  unsigned int Size;
  unsigned int TimeDateStamp;
  unsigned __int16 MajorVersion;
  unsigned __int16 MinorVersion;
  unsigned int GlobalFlagsClear;
  unsigned int GlobalFlagsSet;
  unsigned int CriticalSectionDefaultTimeout;
  unsigned __int64 DeCommitFreeBlockThreshold;
  unsigned __int64 DeCommitTotalFreeThreshold;
  unsigned __int64 LockPrefixTable;
  unsigned __int64 MaximumAllocationSize;
  unsigned __int64 VirtualMemoryThreshold;
  unsigned __int64 ProcessAffinityMask;
  unsigned int ProcessHeapFlags;
  unsigned __int16 CSDVersion;
  unsigned __int16 Reserved1;
  unsigned __int64 EditList;
  unsigned __int64 SecurityCookie;
  unsigned __int64 SEHandlerTable;
  unsigned __int64 SEHandlerCount;
};


struct tagEMRSETPIXELV
{
  tagEMR emr;
  _POINTL ptlPixel;
  unsigned int crColor;
};


struct linger
{
  unsigned __int16 l_onoff;
  unsigned __int16 l_linger;
};


union $8662F439D215AAEDBB1F787C8B649648
{
  unsigned __int64 FiberData;
  unsigned int Version;
};


struct _NT_TIB64
{
  unsigned __int64 ExceptionList;
  unsigned __int64 StackBase;
  unsigned __int64 StackLimit;
  unsigned __int64 SubSystemTib;
  $8662F439D215AAEDBB1F787C8B649648 ___u4;
  unsigned __int64 ArbitraryUserPointer;
  unsigned __int64 Self;
};


struct _ABCFLOAT
{
  float abcfA;
  float abcfB;
  float abcfC;
};


struct _IMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY
{
  unsigned __int64 BeginAddress;
  unsigned __int64 EndAddress;
  unsigned __int64 ExceptionHandler;
  unsigned __int64 HandlerData;
  unsigned __int64 PrologEndAddress;
};


struct _CONSOLE_CURSOR_INFO
{
  unsigned int dwSize;
  int bVisible;
};


struct _CERT_NAME_VALUE
{
  unsigned int dwValueType;
  _CRYPTOAPI_BLOB Value;
};


struct _CPS_URLS
{
  unsigned __int16 *pszURL;
  _CRYPT_ALGORITHM_IDENTIFIER *pAlgorithm;
  _CRYPTOAPI_BLOB *pDigest;
};


struct _TAPE_GET_MEDIA_PARAMETERS
{
  _LARGE_INTEGER Capacity;
  _LARGE_INTEGER Remaining;
  unsigned int BlockSize;
  unsigned int PartitionCount;
  char WriteProtected;
};


struct _PROV_ENUMALGS
{
  unsigned int aiAlgid;
  unsigned int dwBitLen;
  unsigned int dwNameLen;
  char szName[20];
};


struct _wfinddatai64_t
{
  unsigned int attrib;
  int time_create;
  int time_access;
  int time_write;
  __int64 size;
  wchar_t name[260];
};


struct _CRL_ISSUING_DIST_POINT
{
  _CRL_DIST_POINT_NAME DistPointName;
  int fOnlyContainsUserCerts;
  int fOnlyContainsCACerts;
  _CRYPT_BIT_BLOB OnlySomeReasonFlags;
  int fIndirectCRL;
};


struct _SERVICE_DESCRIPTIONA
{
  char *lpDescription;
};


struct _CRYPT_ENROLLMENT_NAME_VALUE_PAIR
{
  unsigned __int16 *pwszName;
  unsigned __int16 *pwszValue;
};


struct timeval
{
  int tv_sec;
  int tv_usec;
};


struct tagBITMAP
{
  int bmType;
  int bmWidth;
  int bmHeight;
  int bmWidthBytes;
  unsigned __int16 bmPlanes;
  unsigned __int16 bmBitsPixel;
  void *bmBits;
};


struct tagDIBSECTION
{
  tagBITMAP dsBm;
  tagBITMAPINFOHEADER dsBmih;
  unsigned int dsBitfields[3];
  void *dshSection;
  unsigned int dsOffset;
};


struct _WIN32_STREAM_ID
{
  unsigned int dwStreamId;
  unsigned int dwStreamAttributes;
  _LARGE_INTEGER Size;
  unsigned int dwStreamNameSize;
  unsigned __int16 cStreamName[1];
};


struct _TOKEN_OWNER
{
  void *Owner;
};


struct _CMSG_RC4_AUX_INFO
{
  unsigned int cbSize;
  unsigned int dwBitLen;
};


struct _EVENTSFORLOGFILE
{
  unsigned int ulSize;
  unsigned __int16 szLogicalLogFile[256];
  unsigned int ulNumRecords;
  _EVENTLOGRECORD pEventLogRecords[];
};


struct _IMAGE_RESOURCE_DIRECTORY_STRING
{
  unsigned __int16 Length;
  char NameString[1];
};


struct _CRYPT_CSP_PROVIDER
{
  unsigned int dwKeySpec;
  unsigned __int16 *pwszProviderName;
  _CRYPT_BIT_BLOB Signature;
};


struct _ACCESS_DENIED_OBJECT_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int Flags;
  _GUID ObjectType;
  _GUID InheritedObjectType;
  unsigned int SidStart;
};


struct _IMAGE_DOS_HEADER
{
  unsigned __int16 e_magic;
  unsigned __int16 e_cblp;
  unsigned __int16 e_cp;
  unsigned __int16 e_crlc;
  unsigned __int16 e_cparhdr;
  unsigned __int16 e_minalloc;
  unsigned __int16 e_maxalloc;
  unsigned __int16 e_ss;
  unsigned __int16 e_sp;
  unsigned __int16 e_csum;
  unsigned __int16 e_ip;
  unsigned __int16 e_cs;
  unsigned __int16 e_lfarlc;
  unsigned __int16 e_ovno;
  unsigned __int16 e_res[4];
  unsigned __int16 e_oemid;
  unsigned __int16 e_oeminfo;
  unsigned __int16 e_res2[10];
  int e_lfanew;
};


struct _CTL_ANY_SUBJECT_INFO
{
  _CRYPT_ALGORITHM_IDENTIFIER SubjectAlgorithm;
  _CRYPTOAPI_BLOB SubjectIdentifier;
};


struct _PRIVKEYVER3
{
  unsigned int magic;
  unsigned int bitlenP;
  unsigned int bitlenQ;
  unsigned int bitlenJ;
  unsigned int bitlenX;
  _DSSSEED DSSSeed;
};


struct tagLASTINPUTINFO
{
  unsigned int cbSize;
  unsigned int dwTime;
};


struct tagIMEMENUITEMINFOW
{
  unsigned int cbSize;
  unsigned int fType;
  unsigned int fState;
  unsigned int wID;
  HBITMAP__ *hbmpChecked;
  HBITMAP__ *hbmpUnchecked;
  unsigned int dwItemData;
  unsigned __int16 szString[80];
  HBITMAP__ *hbmpItem;
};


struct tagCOLORADJUSTMENT
{
  unsigned __int16 caSize;
  unsigned __int16 caFlags;
  unsigned __int16 caIlluminantIndex;
  unsigned __int16 caRedGamma;
  unsigned __int16 caGreenGamma;
  unsigned __int16 caBlueGamma;
  unsigned __int16 caReferenceBlack;
  unsigned __int16 caReferenceWhite;
  __int16 caContrast;
  __int16 caBrightness;
  __int16 caColorfulness;
  __int16 caRedGreenTint;
};


struct tagEMRSETCOLORADJUSTMENT
{
  tagEMR emr;
  tagCOLORADJUSTMENT ColorAdjustment;
};


struct _CERT_NAME_INFO
{
  unsigned int cRDN;
  _CERT_RDN *rgRDN;
};


struct tagNONCLIENTMETRICSW
{
  unsigned int cbSize;
  int iBorderWidth;
  int iScrollWidth;
  int iScrollHeight;
  int iCaptionWidth;
  int iCaptionHeight;
  tagLOGFONTW lfCaptionFont;
  int iSmCaptionWidth;
  int iSmCaptionHeight;
  tagLOGFONTW lfSmCaptionFont;
  int iMenuWidth;
  int iMenuHeight;
  tagLOGFONTW lfMenuFont;
  tagLOGFONTW lfStatusFont;
  tagLOGFONTW lfMessageFont;
};


struct tagEMRSETVIEWPORTORGEX
{
  tagEMR emr;
  _POINTL ptlOrigin;
};


struct _SERVICE_TABLE_ENTRYA
{
  char *lpServiceName;
  void (__stdcall *lpServiceProc)(unsigned int, char **);
};


struct _MENU_EVENT_RECORD
{
  unsigned int dwCommandId;
};


struct _RGNDATAHEADER
{
  unsigned int dwSize;
  unsigned int iType;
  unsigned int nCount;
  unsigned int nRgnSize;
  tagRECT rcBound;
};


struct _RGNDATA
{
  _RGNDATAHEADER rdh;
  char Buffer[1];
};


struct _REMOTE_NAME_INFOA
{
  char *lpUniversalName;
  char *lpConnectionName;
  char *lpRemainingPath;
};


struct _CMSG_STREAM_INFO
{
  unsigned int cbContent;
  int (__stdcall *pfnStreamOutput)(const void *, char *, unsigned int, int);
  void *pvArg;
};


struct tagFILTERKEYS
{
  unsigned int cbSize;
  unsigned int dwFlags;
  unsigned int iWaitMSec;
  unsigned int iDelayMSec;
  unsigned int iRepeatMSec;
  unsigned int iBounceMSec;
};


struct _CMSG_SIGNED_AND_ENVELOPED_ENCODE_INFO
{
  unsigned int cbSize;
  _CMSG_SIGNED_ENCODE_INFO SignedInfo;
  _CMSG_ENVELOPED_ENCODE_INFO EnvelopedInfo;
};


struct tagEMRSETTEXTCOLOR
{
  tagEMR emr;
  unsigned int crColor;
};


struct _AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_PARA
{
  unsigned int cbSize;
  unsigned int dwRegPolicySettings;
  _CMSG_SIGNER_INFO *pSignerInfo;
};


struct _DOCINFOW
{
  int cbSize;
  const unsigned __int16 *lpszDocName;
  const unsigned __int16 *lpszOutput;
  const unsigned __int16 *lpszDatatype;
  unsigned int fwType;
};


struct tagDELETEITEMSTRUCT
{
  unsigned int CtlType;
  unsigned int CtlID;
  unsigned int itemID;
  HWND__ *hwndItem;
  unsigned int itemData;
};


struct _WSANETWORKEVENTS
{
  int lNetworkEvents;
  int iErrorCode[10];
};


struct _s__ThrowInfo
{
  unsigned int attributes;
  void (__cdecl *pmfnUnwind)();
  int (__cdecl *pForwardCompat)();
  _s__CatchableTypeArray *pCatchableTypeArray;
};


struct tagMONITORINFOEXW
{
  tagMONITORINFO baseclass_0;
  unsigned __int16 szDevice[32];
};


struct _SPC_STATEMENT_TYPE
{
  unsigned int cKeyPurposeId;
  char **rgpszKeyPurposeId;
};


struct _SYSTEM_POWER_POLICY
{
  unsigned int Revision;
  POWER_ACTION_POLICY PowerButton;
  POWER_ACTION_POLICY SleepButton;
  POWER_ACTION_POLICY LidClose;
  _SYSTEM_POWER_STATE LidOpenWake;
  unsigned int Reserved;
  POWER_ACTION_POLICY Idle;
  unsigned int IdleTimeout;
  char IdleSensitivity;
  char DynamicThrottle;
  char Spare2[2];
  _SYSTEM_POWER_STATE MinSleep;
  _SYSTEM_POWER_STATE MaxSleep;
  _SYSTEM_POWER_STATE ReducedLatencySleep;
  unsigned int WinLogonFlags;
  unsigned int Spare3;
  unsigned int DozeS4Timeout;
  unsigned int BroadcastCapacityResolution;
  SYSTEM_POWER_LEVEL DischargePolicy[4];
  unsigned int VideoTimeout;
  char VideoDimDisplay;
  unsigned int VideoReserved[3];
  unsigned int SpindownTimeout;
  char OptimizeForPower;
  char FanThrottleTolerance;
  char ForcedThrottle;
  char MinThrottle;
  POWER_ACTION_POLICY OverThrottled;
};


struct _MINIDUMP_SYSTEM_INFO::_CPU_INFORMATION::__unnamed
{
  unsigned int VendorId[3];
  unsigned int VersionInformation;
  unsigned int FeatureInformation;
  unsigned int AMDExtendedCpuFeatures;
};


union _MINIDUMP_SYSTEM_INFO::_CPU_INFORMATION
{
  _MINIDUMP_SYSTEM_INFO::_CPU_INFORMATION::__unnamed X86CpuInfo;
  _MINIDUMP_SYSTEM_INFO::_CPU_INFORMATION::__unnamed OtherCpuInfo;
};


struct $1A2EF21622AC59D9D97D6BC08126477B
{
  char NumberOfProcessors;
  char ProductType;
};


union $6FBD730F29B5AB5E872AAE10B04BC42C
{
  unsigned __int16 Reserved0;
  $1A2EF21622AC59D9D97D6BC08126477B _s1;
};


struct $E9C8715B6438826DC7F871522AFE6DED
{
  unsigned __int16 SuiteMask;
  unsigned __int16 Reserved2;
};


union $62935822D2DC26A0A98C3008CC8FCD8A
{
  unsigned int Reserved1;
  $E9C8715B6438826DC7F871522AFE6DED _s1;
};


struct _MINIDUMP_SYSTEM_INFO
{
  unsigned __int16 ProcessorArchitecture;
  unsigned __int16 ProcessorLevel;
  unsigned __int16 ProcessorRevision;
  $6FBD730F29B5AB5E872AAE10B04BC42C ___u3;
  unsigned int MajorVersion;
  unsigned int MinorVersion;
  unsigned int BuildNumber;
  unsigned int PlatformId;
  unsigned int CSDVersionRva;
  $62935822D2DC26A0A98C3008CC8FCD8A ___u9;
  _MINIDUMP_SYSTEM_INFO::_CPU_INFORMATION Cpu;
};


struct _IMAGE_RESOURCE_DIR_STRING_U
{
  unsigned __int16 Length;
  unsigned __int16 NameString[1];
};


struct tagEMRMASKBLT
{
  tagEMR emr;
  _RECTL rclBounds;
  int xDest;
  int yDest;
  int cxDest;
  int cyDest;
  unsigned int dwRop;
  int xSrc;
  int ySrc;
  tagXFORM xformSrc;
  unsigned int crBkColorSrc;
  unsigned int iUsageSrc;
  unsigned int offBmiSrc;
  unsigned int cbBmiSrc;
  unsigned int offBitsSrc;
  unsigned int cbBitsSrc;
  int xMask;
  int yMask;
  unsigned int iUsageMask;
  unsigned int offBmiMask;
  unsigned int cbBmiMask;
  unsigned int offBitsMask;
  unsigned int cbBitsMask;
};


struct BATTERY_REPORTING_SCALE
{
  unsigned int Granularity;
  unsigned int Capacity;
};


struct tagEMRPIXELFORMAT
{
  tagEMR emr;
  tagPIXELFORMATDESCRIPTOR pfd;
};


struct _SYSTEM_AUDIT_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int SidStart;
};


struct SERVICE_STATUS_HANDLE__
{
  int unused;
};


struct tagMENUINFO
{
  unsigned int cbSize;
  unsigned int fMask;
  unsigned int dwStyle;
  unsigned int cyMax;
  HBRUSH__ *hbrBack;
  unsigned int dwContextHelpID;
  unsigned int dwMenuData;
};


struct _ICONINFO
{
  int fIcon;
  unsigned int xHotspot;
  unsigned int yHotspot;
  HBITMAP__ *hbmMask;
  HBITMAP__ *hbmColor;
};


struct _CRYPTPROTECT_PROMPTSTRUCT
{
  unsigned int cbSize;
  unsigned int dwPromptFlags;
  HWND__ *hwndApp;
  const unsigned __int16 *szPrompt;
};


struct _RTL_VERIFIER_PROVIDER_DESCRIPTOR
{
  unsigned int Length;
  _RTL_VERIFIER_DLL_DESCRIPTOR *ProviderDlls;
  void (__stdcall *ProviderDllLoadCallback)(unsigned __int16 *, void *, unsigned int, void *);
  void (__stdcall *ProviderDllUnloadCallback)(unsigned __int16 *, void *, unsigned int, void *);
  unsigned __int16 *VerifierImage;
  unsigned int VerifierFlags;
  unsigned int VerifierDebug;
  void *RtlpGetStackTraceAddress;
  void *RtlpDebugPageHeapCreate;
  void *RtlpDebugPageHeapDestroy;
};


struct _PROCESS_INFORMATION
{
  void *hProcess;
  void *hThread;
  unsigned int dwProcessId;
  unsigned int dwThreadId;
};


struct _cpinfo
{
  unsigned int MaxCharSize;
  char DefaultChar[2];
  char LeadByte[12];
};


struct _CRYPT_SEQUENCE_OF_ANY
{
  unsigned int cValue;
  _CRYPTOAPI_BLOB *rgValue;
};


struct SHELLHOOKINFO
{
  HWND__ *hwnd;
  tagRECT rc;
};


struct _PSFEATURE_OUTPUT
{
  int bPageIndependent;
  int bSetPageDevice;
};


struct _wfinddata_t
{
  unsigned int attrib;
  int time_create;
  int time_access;
  int time_write;
  unsigned int size;
  wchar_t name[260];
};


struct _SYSTEM_AUDIT_OBJECT_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int Flags;
  _GUID ObjectType;
  _GUID InheritedObjectType;
  unsigned int SidStart;
};


struct netent
{
  char *n_name;
  char **n_aliases;
  __int16 n_addrtype;
  unsigned int n_net;
};


struct _CRYPT_PKCS8_IMPORT_PARAMS
{
  _CRYPTOAPI_BLOB PrivateKey;
  int (__stdcall *pResolvehCryptProvFunc)(_CRYPT_PRIVATE_KEY_INFO *, unsigned int *, void *);
  void *pVoidResolveFunc;
  int (__stdcall *pDecryptPrivateKeyFunc)(_CRYPT_ALGORITHM_IDENTIFIER, _CRYPTOAPI_BLOB, char *, unsigned int *, void *);
  void *pVoidDecryptFunc;
};


struct tagEMRGDICOMMENT
{
  tagEMR emr;
  unsigned int cbData;
  char Data[1];
};


struct _CRYPT_ENCRYPT_MESSAGE_PARA
{
  unsigned int cbSize;
  unsigned int dwMsgEncodingType;
  unsigned int hCryptProv;
  _CRYPT_ALGORITHM_IDENTIFIER ContentEncryptionAlgorithm;
  void *pvEncryptionAuxInfo;
  unsigned int dwFlags;
  unsigned int dwInnerContentType;
};


struct tagCURSORSHAPE
{
  int xHotSpot;
  int yHotSpot;
  int cx;
  int cy;
  int cbWidth;
  char Planes;
  char BitsPixel;
};


struct _IMAGEHLP_CBA_EVENT
{
  unsigned int severity;
  unsigned int code;
  char *desc;
  void *object;
};


struct provider_info
{
  unsigned int (__cdecl *pi_R0_1val)(void *, val_context *, unsigned int, void *, unsigned int *, unsigned int);
  unsigned int (__cdecl *pi_R0_allvals)(void *, val_context *, unsigned int, void *, unsigned int *, unsigned int);
  unsigned int (__cdecl *pi_R3_1val)(void *, val_context *, unsigned int, void *, unsigned int *, unsigned int);
  unsigned int (__cdecl *pi_R3_allvals)(void *, val_context *, unsigned int, void *, unsigned int *, unsigned int);
  unsigned int pi_flags;
  void *pi_key_context;
};


struct _CERT_SYSTEM_STORE_INFO
{
  unsigned int cbSize;
};


struct HCOLORSPACE__
{
  int unused;
};


struct _TAPE_CREATE_PARTITION
{
  unsigned int Method;
  unsigned int Count;
  unsigned int Size;
};


struct tagEMRSETCOLORSPACE
{
  tagEMR emr;
  unsigned int ihCS;
};


struct tagSOUNDSENTRYW
{
  unsigned int cbSize;
  unsigned int dwFlags;
  unsigned int iFSTextEffect;
  unsigned int iFSTextEffectMSec;
  unsigned int iFSTextEffectColorBits;
  unsigned int iFSGrafEffect;
  unsigned int iFSGrafEffectMSec;
  unsigned int iFSGrafEffectColor;
  unsigned int iWindowsEffect;
  unsigned int iWindowsEffectMSec;
  unsigned __int16 *lpszWindowsEffectDLL;
  unsigned int iWindowsEffectOrdinal;
};


struct _CERT_REGISTRY_STORE_CLIENT_GPT_PARA
{
  HKEY__ *hKeyBase;
  unsigned __int16 *pwszRegPath;
};


struct tagENUMLOGFONTW
{
  tagLOGFONTW elfLogFont;
  unsigned __int16 elfFullName[64];
  unsigned __int16 elfStyle[32];
};


struct _TOKEN_AUDIT_POLICY
{
  unsigned int PolicyCount;
  _TOKEN_AUDIT_POLICY_ELEMENT Policy[1];
};


union _IMAGE_SECTION_HEADER::__unnamed
{
  unsigned int PhysicalAddress;
  unsigned int VirtualSize;
};


struct _CONSOLE_FONT_INFO
{
  unsigned int nFont;
  _COORD dwFontSize;
};


struct _DISCDLGSTRUCTW
{
  unsigned int cbStructure;
  HWND__ *hwndOwner;
  unsigned __int16 *lpLocalName;
  unsigned __int16 *lpRemoteName;
  unsigned int dwFlags;
};


struct _JOBOBJECT_BASIC_PROCESS_ID_LIST
{
  unsigned int NumberOfAssignedProcesses;
  unsigned int NumberOfProcessIdsInList;
  unsigned int ProcessIdList[1];
};


struct _FILE_NOTIFY_INFORMATION
{
  unsigned int NextEntryOffset;
  unsigned int Action;
  unsigned int FileNameLength;
  unsigned __int16 FileName[1];
};


struct _MINIDUMP_UNLOADED_MODULE
{
  unsigned __int64 BaseOfImage;
  unsigned int SizeOfImage;
  unsigned int CheckSum;
  unsigned int TimeDateStamp;
  unsigned int ModuleNameRva;
};


struct _IMAGE_RESOURCE_DIRECTORY
{
  unsigned int Characteristics;
  unsigned int TimeDateStamp;
  unsigned __int16 MajorVersion;
  unsigned __int16 MinorVersion;
  unsigned __int16 NumberOfNamedEntries;
  unsigned __int16 NumberOfIdEntries;
};


struct tagCOMPOSITIONFORM
{
  unsigned int dwStyle;
  tagPOINT ptCurrentPos;
  tagRECT rcArea;
};


struct _SERVICE_DESCRIPTIONW
{
  unsigned __int16 *lpDescription;
};


struct _ldiv_t
{
  int quot;
  int rem;
};


union $E38888FFFF2E8047BDBD55C921E86469
{
  unsigned int FiberData;
  unsigned int Version;
};


struct _NT_TIB32
{
  unsigned int ExceptionList;
  unsigned int StackBase;
  unsigned int StackLimit;
  unsigned int SubSystemTib;
  $E38888FFFF2E8047BDBD55C921E86469 ___u4;
  unsigned int ArbitraryUserPointer;
  unsigned int Self;
};


struct _IMAGE_NT_HEADERS64
{
  unsigned int Signature;
  _IMAGE_FILE_HEADER FileHeader;
  _IMAGE_OPTIONAL_HEADER64 OptionalHeader;
};


struct _IMAGE_TLS_DIRECTORY64
{
  unsigned __int64 StartAddressOfRawData;
  unsigned __int64 EndAddressOfRawData;
  unsigned __int64 AddressOfIndex;
  unsigned __int64 AddressOfCallBacks;
  unsigned int SizeOfZeroFill;
  unsigned int Characteristics;
};


struct _CERT_EXTENSIONS
{
  unsigned int cExtension;
  _CERT_EXTENSION *rgExtension;
};


struct _CMC_DATA_INFO
{
  unsigned int cTaggedAttribute;
  _CMC_TAGGED_ATTRIBUTE *rgTaggedAttribute;
  unsigned int cTaggedRequest;
  _CMC_TAGGED_REQUEST *rgTaggedRequest;
  unsigned int cTaggedContentInfo;
  _CMC_TAGGED_CONTENT_INFO *rgTaggedContentInfo;
  unsigned int cTaggedOtherMsg;
  _CMC_TAGGED_OTHER_MSG *rgTaggedOtherMsg;
};


struct stat
{
  unsigned int st_dev;
  unsigned __int16 st_ino;
  unsigned __int16 st_mode;
  __int16 st_nlink;
  __int16 st_uid;
  __int16 st_gid;
  unsigned int st_rdev;
  int st_size;
  int st_atime;
  int st_mtime;
  int st_ctime;
};


struct tagEMRGRADIENTFILL
{
  tagEMR emr;
  _RECTL rclBounds;
  unsigned int nVer;
  unsigned int nTri;
  unsigned int ulMode;
  _TRIVERTEX Ver[1];
};


struct _CRYPT_DECODE_PARA
{
  unsigned int cbSize;
  void *(__stdcall *pfnAlloc)(unsigned int);
  void (__stdcall *pfnFree)(void *);
};


struct _TI_FINDCHILDREN_PARAMS
{
  unsigned int Count;
  unsigned int Start;
  unsigned int ChildId[1];
};


struct _SE_IMPERSONATION_STATE
{
  void *Token;
  char CopyOnOpen;
  char EffectiveOnly;
  _SECURITY_IMPERSONATION_LEVEL Level;
};


struct tagEMREXTFLOODFILL
{
  tagEMR emr;
  _POINTL ptlStart;
  unsigned int crColor;
  unsigned int iMode;
};


struct _ACCESS_ALLOWED_CALLBACK_ACE
{
  _ACE_HEADER Header;
  unsigned int Mask;
  unsigned int SidStart;
};


struct _EVENTLOG_FULL_INFORMATION
{
  unsigned int dwFull;
};


struct tagCBT_CREATEWNDA
{
  tagCREATESTRUCTA *lpcs;
  HWND__ *hwndInsertAfter;
};


struct HHOOK__
{
  int unused;
};


struct _AUTHENTICODE_EXTRA_CERT_CHAIN_POLICY_STATUS
{
  unsigned int cbSize;
  int fCommercial;
};


struct _REPARSE_GUID_DATA_BUFFER::__unnamed
{
  char DataBuffer[1];
};


struct _REPARSE_GUID_DATA_BUFFER
{
  unsigned int ReparseTag;
  unsigned __int16 ReparseDataLength;
  unsigned __int16 Reserved;
  _GUID ReparseGuid;
  _REPARSE_GUID_DATA_BUFFER::__unnamed GenericReparseBuffer;
};


struct _SECURITY_DESCRIPTOR
{
  char Revision;
  char Sbz1;
  unsigned __int16 Control;
  void *Owner;
  void *Group;
  _ACL *Sacl;
  _ACL *Dacl;
};


struct _CRYPT_ENCRYPTED_PRIVATE_KEY_INFO
{
  _CRYPT_ALGORITHM_IDENTIFIER EncryptionAlgorithm;
  _CRYPTOAPI_BLOB EncryptedPrivateKey;
};


struct __stat64
{
  unsigned int st_dev;
  unsigned __int16 st_ino;
  unsigned __int16 st_mode;
  __int16 st_nlink;
  __int16 st_uid;
  __int16 st_gid;
  unsigned int st_rdev;
  __int64 st_size;
  __int64 st_atime;
  __int64 st_mtime;
  __int64 st_ctime;
};


struct tagTTPOLYCURVE
{
  unsigned __int16 wType;
  unsigned __int16 cpfx;
  tagPOINTFX apfx[1];
};


struct tagHW_PROFILE_INFOW
{
  unsigned int dwDockInfo;
  unsigned __int16 szHwProfileGuid[39];
  unsigned __int16 szHwProfileName[80];
};


struct bad_cast
{
  exception baseclass_0;
};


struct _TAPE_PREPARE
{
  unsigned int Operation;
  char Immediate;
};


union _CHAR_INFO::__unnamed
{
  unsigned __int16 UnicodeChar;
  char AsciiChar;
};


struct _CHAR_INFO
{
  _CHAR_INFO::__unnamed Char;
  unsigned __int16 Attributes;
};


struct tagEMRCREATEPALETTE
{
  tagEMR emr;
  unsigned int ihPal;
  tagLOGPALETTE lgpl;
};


struct _JOBOBJECT_BASIC_UI_RESTRICTIONS
{
  unsigned int UIRestrictionsClass;
};


struct LIST_ENTRY64
{
  unsigned __int64 Flink;
  unsigned __int64 Blink;
};


struct HPEN__
{
  int unused;
};


struct _SECURITY_QUALITY_OF_SERVICE
{
  unsigned int Length;
  _SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
  char ContextTrackingMode;
  char EffectiveOnly;
};


struct tagDRAWITEMSTRUCT
{
  unsigned int CtlType;
  unsigned int CtlID;
  unsigned int itemID;
  unsigned int itemAction;
  unsigned int itemState;
  HWND__ *hwndItem;
  HDC__ *hDC;
  tagRECT rcItem;
  unsigned int itemData;
};


struct _stati64
{
  unsigned int st_dev;
  unsigned __int16 st_ino;
  unsigned __int16 st_mode;
  __int16 st_nlink;
  __int16 st_uid;
  __int16 st_gid;
  unsigned int st_rdev;
  __int64 st_size;
  int st_atime;
  int st_mtime;
  int st_ctime;
};


struct _CRYPT_URL_INFO
{
  unsigned int cbSize;
  unsigned int dwSyncDeltaTime;
  unsigned int cGroup;
  unsigned int *rgcGroupEntry;
};


struct _CAT_NAMEVALUE
{
  unsigned __int16 *pwszTag;
  unsigned int fdwFlags;
  _CRYPTOAPI_BLOB Value;
};


struct _TAPE_GET_DRIVE_PARAMETERS
{
  char ECC;
  char Compression;
  char DataPadding;
  char ReportSetmarks;
  unsigned int DefaultBlockSize;
  unsigned int MaximumBlockSize;
  unsigned int MinimumBlockSize;
  unsigned int MaximumPartitionCount;
  unsigned int FeaturesLow;
  unsigned int FeaturesHigh;
  unsigned int EOTWarningZoneSize;
};


struct _CTL_USAGE_MATCH
{
  unsigned int dwType;
  _CTL_USAGE Usage;
};


struct _CrtMemState
{
  _CrtMemBlockHeader *pBlockHeader;
  unsigned int lCounts[5];
  unsigned int lSizes[5];
  unsigned int lHighWaterCount;
  unsigned int lTotalCount;
};


struct _TAPE_SET_MEDIA_PARAMETERS
{
  unsigned int BlockSize;
};


struct tagMDICREATESTRUCTW
{
  const unsigned __int16 *szClass;
  const unsigned __int16 *szTitle;
  void *hOwner;
  int x;
  int y;
  int cx;
  int cy;
  unsigned int style;
  int lParam;
};


struct _CONSOLE_SELECTION_INFO
{
  unsigned int dwFlags;
  _COORD dwSelectionAnchor;
  _SMALL_RECT srSelection;
};


struct SYSTEM_POWER_CAPABILITIES
{
  char PowerButtonPresent;
  char SleepButtonPresent;
  char LidPresent;
  char SystemS1;
  char SystemS2;
  char SystemS3;
  char SystemS4;
  char SystemS5;
  char HiberFilePresent;
  char FullWake;
  char VideoDimPresent;
  char ApmPresent;
  char UpsPresent;
  char ThermalControl;
  char ProcessorThrottle;
  char ProcessorMinThrottle;
  char ProcessorMaxThrottle;
  char spare2[4];
  char DiskSpinDown;
  char spare3[8];
  char SystemBatteriesPresent;
  char BatteriesAreShortTerm;
  BATTERY_REPORTING_SCALE BatteryScale[3];
  _SYSTEM_POWER_STATE AcOnLineWake;
  _SYSTEM_POWER_STATE SoftLidWake;
  _SYSTEM_POWER_STATE RtcWake;
  _SYSTEM_POWER_STATE MinDeviceWakeState;
  _SYSTEM_POWER_STATE DefaultLowLatencyWake;
};


struct _IMAGEHLP_SYMBOL64_PACKAGE
{
  _IMAGEHLP_SYMBOL64 sym;
  char name[2001];
};


struct tagEMRGLSBOUNDEDRECORD
{
  tagEMR emr;
  _RECTL rclBounds;
  unsigned int cbData;
  char Data[1];
};


union $980F6A28C67C8F3640106D01D4C85A6A
{
  unsigned int Characteristics;
  unsigned int OriginalFirstThunk;
};


struct _IMAGE_IMPORT_DESCRIPTOR
{
  $980F6A28C67C8F3640106D01D4C85A6A ___u0;
  unsigned int TimeDateStamp;
  unsigned int ForwarderChain;
  unsigned int Name;
  unsigned int FirstThunk;
};


struct _DRAWPATRECT
{
  tagPOINT ptPosition;
  tagPOINT ptSize;
  unsigned __int16 wStyle;
  unsigned __int16 wPattern;
};


struct tagEMRBITBLT
{
  tagEMR emr;
  _RECTL rclBounds;
  int xDest;
  int yDest;
  int cxDest;
  int cyDest;
  unsigned int dwRop;
  int xSrc;
  int ySrc;
  tagXFORM xformSrc;
  unsigned int crBkColorSrc;
  unsigned int iUsageSrc;
  unsigned int offBmiSrc;
  unsigned int cbBmiSrc;
  unsigned int offBitsSrc;
  unsigned int cbBitsSrc;
};


struct _SERVICE_FAILURE_ACTIONSW
{
  unsigned int dwResetPeriod;
  unsigned __int16 *lpRebootMsg;
  unsigned __int16 *lpCommand;
  unsigned int cActions;
  _SC_ACTION *lpsaActions;
};


struct _SID
{
  char Revision;
  char SubAuthorityCount;
  _SID_IDENTIFIER_AUTHORITY IdentifierAuthority;
  unsigned int SubAuthority[1];
};


struct tagEMRSETMAPPERFLAGS
{
  tagEMR emr;
  unsigned int dwFlags;
};


struct tagMDINEXTMENU
{
  HMENU__ *hmenuIn;
  HMENU__ *hmenuNext;
  HWND__ *hwndNext;
};


struct bad_typeid
{
  exception baseclass_0;
};


struct __non_rtti_object
{
  bad_typeid baseclass_0;
};


struct tagEMRSETPALETTEENTRIES
{
  tagEMR emr;
  unsigned int ihPal;
  unsigned int iStart;
  unsigned int cEntries;
  tagPALETTEENTRY aPalEntries[1];
};


struct _WIN_TRUST_SUBJECT_FILE_AND_DISPLAY
{
  void *hFile;
  const unsigned __int16 *lpPath;
  const unsigned __int16 *lpDisplayName;
};


struct _EXCEPTION_RECORD64
{
  unsigned int ExceptionCode;
  unsigned int ExceptionFlags;
  unsigned __int64 ExceptionRecord;
  unsigned __int64 ExceptionAddress;
  unsigned int NumberParameters;
  unsigned int __unusedAlignment;
  unsigned __int64 ExceptionInformation[15];
};


struct tagEMRRESIZEPALETTE
{
  tagEMR emr;
  unsigned int ihPal;
  unsigned int cEntries;
};


struct _OBJECT_TYPE_LIST
{
  unsigned __int16 Level;
  unsigned __int16 Sbz;
  _GUID *ObjectType;
};


struct _TIME_ZONE_INFORMATION
{
  int Bias;
  unsigned __int16 StandardName[32];
  _SYSTEMTIME StandardDate;
  int StandardBias;
  unsigned __int16 DaylightName[32];
  _SYSTEMTIME DaylightDate;
  int DaylightBias;
};


struct _CERT_POLICY95_QUALIFIER1
{
  unsigned __int16 *pszPracticesReference;
  char *pszNoticeIdentifier;
  char *pszNSINoticeIdentifier;
  unsigned int cCPSURLs;
  _CPS_URLS *rgCPSURLs;
};


struct tagTPMPARAMS
{
  unsigned int cbSize;
  tagRECT rcExclude;
};


struct pvalueW
{
  unsigned __int16 *pv_valuename;
  int pv_valuelen;
  void *pv_value_context;
  unsigned int pv_type;
};


struct _WINDOW_BUFFER_SIZE_RECORD
{
  _COORD dwSize;
};


union _INPUT_RECORD::__unnamed
{
  _KEY_EVENT_RECORD KeyEvent;
  _MOUSE_EVENT_RECORD MouseEvent;
  _WINDOW_BUFFER_SIZE_RECORD WindowBufferSizeEvent;
  _MENU_EVENT_RECORD MenuEvent;
  _FOCUS_EVENT_RECORD FocusEvent;
};


struct _INPUT_RECORD
{
  unsigned __int16 EventType;
  _INPUT_RECORD::__unnamed Event;
};


union $9BDD8B5C5DE01E64F58E9195BF0B8F3F
{
  HKEY__ *hKeyBase;
  void *pvBase;
};


union $644E3772CE471009796AF877D4363EF9
{
  void *pvSystemStore;
  const char *pszSystemStore;
  const unsigned __int16 *pwszSystemStore;
};


struct _CERT_SYSTEM_STORE_RELOCATE_PARA
{
  $9BDD8B5C5DE01E64F58E9195BF0B8F3F ___u0;
  $644E3772CE471009796AF877D4363EF9 ___u1;
};


struct tm
{
  int tm_sec;
  int tm_min;
  int tm_hour;
  int tm_mday;
  int tm_mon;
  int tm_year;
  int tm_wday;
  int tm_yday;
  int tm_isdst;
};


struct _MINIDUMP_LOCATION_DESCRIPTOR64
{
  unsigned __int64 DataSize;
  unsigned __int64 Rva;
};


struct _PSFEATURE_CUSTPAPER
{
  int lOrientation;
  int lWidth;
  int lHeight;
  int lWidthOffset;
  int lHeightOffset;
};


union _IMAGE_THUNK_DATA64::__unnamed
{
  unsigned __int64 ForwarderString;
  unsigned __int64 Function;
  unsigned __int64 Ordinal;
  unsigned __int64 AddressOfData;
};


struct _IMAGE_THUNK_DATA64
{
  _IMAGE_THUNK_DATA64::__unnamed u1;
};


struct protoent
{
  char *p_name;
  char **p_aliases;
  __int16 p_proto;
};


struct HDESK__
{
  int unused;
};


struct _QOS_SD_MODE
{
  QOS_OBJECT_HDR ObjectHdr;
  unsigned int ShapeDiscardMode;
};


struct MENUITEMTEMPLATE
{
  unsigned __int16 mtOption;
  unsigned __int16 mtID;
  unsigned __int16 mtString[1];
};


struct _PUBLICKEYSTRUC
{
  char bType;
  char bVersion;
  unsigned __int16 reserved;
  unsigned int aiKeyAlg;
};


struct tagGCP_RESULTSW
{
  unsigned int lStructSize;
  unsigned __int16 *lpOutString;
  unsigned int *lpOrder;
  int *lpDx;
  int *lpCaretPos;
  char *lpClass;
  unsigned __int16 *lpGlyphs;
  unsigned int nGlyphs;
  int nMaxFit;
};


struct tagHARDWAREHOOKSTRUCT
{
  HWND__ *hwnd;
  unsigned int message;
  unsigned int wParam;
  int lParam;
};


struct _QUOTA_LIMITS_EX
{
  unsigned int PagedPoolLimit;
  unsigned int NonPagedPoolLimit;
  unsigned int MinimumWorkingSetSize;
  unsigned int MaximumWorkingSetSize;
  unsigned int PagefileLimit;
  _LARGE_INTEGER TimeLimit;
  unsigned int Reserved1;
  unsigned int Reserved2;
  unsigned int Reserved3;
  unsigned int Reserved4;
  unsigned int Flags;
  unsigned int Reserved5;
};


struct _IMAGE_IMPORT_BY_NAME
{
  unsigned __int16 Hint;
  char Name[1];
};


struct __s_GUID
{
  unsigned int Data1;
  unsigned __int16 Data2;
  unsigned __int16 Data3;
  char Data4[8];
};


struct _CRYPT_KEY_VERIFY_MESSAGE_PARA
{
  unsigned int cbSize;
  unsigned int dwMsgEncodingType;
  unsigned int hCryptProv;
};


struct _CERT_CHAIN_ENGINE_CONFIG
{
  unsigned int cbSize;
  void *hRestrictedRoot;
  void *hRestrictedTrust;
  void *hRestrictedOther;
  unsigned int cAdditionalStore;
  void **rghAdditionalStore;
  unsigned int dwFlags;
  unsigned int dwUrlRetrievalTimeout;
  unsigned int MaximumCachedCertificates;
  unsigned int CycleDetectionModulus;
};


struct HSTR__
{
  int unused;
};


struct _ACL_REVISION_INFORMATION
{
  unsigned int AclRevision;
};


struct CStatus
{
  char dummy[1];
};


struct CDBSocket
{
  CIOSocket baseclass_0;
};


struct DBPACKET
{
  unsigned __int16 wSize;
  char byType;
  char data[];
};


struct CAuthSocket
{
  CIOSocket baseclass_0;
};


struct AUTHPACKET
{
  unsigned __int16 wSize;
  char byType;
  char data[];
};


struct CFindPath::NODE
{
  $516C50944D3FE9EEE1653A88FD942F0A ___u0;
  unsigned int f;
  unsigned int g;
  unsigned int h;
  int nChild;
  tagPOINT ptPixel;
  CFindPath::NODE *pChild[8];
  CFindPath::NODE *pNext;
  CFindPath::NODE *pNextBest;
};


union $516C50944D3FE9EEE1653A88FD942F0A
{
  CFindPath::NODE *pParent;
  CFindPath::NODE *m_pNext;
};


struct std::_Allocator_base<QUESTITEMDROP>
{
  char dummy[1];
};


struct std::allocator<QUESTITEMDROP>
{
  std::_Allocator_base<QUESTITEMDROP> baseclass_0;
};


struct std::_Vector_val<QUESTITEMDROP,std::allocator<QUESTITEMDROP> >
{
  std::allocator<QUESTITEMDROP> _Alval;
};


struct QUESTITEMDROP
{
  unsigned int dwQuestKey;
  int nItemGroup;
  int nDropNum;
};


struct std::vector<QUESTITEMDROP,std::allocator<QUESTITEMDROP> >
{
  std::_Vector_val<QUESTITEMDROP,std::allocator<QUESTITEMDROP> > baseclass_0;
  QUESTITEMDROP *_Myfirst;
  QUESTITEMDROP *_Mylast;
  QUESTITEMDROP *_Myend;
};


struct CInitMonster
{
  CBase baseclass_0;
  char m_szName[25];
  int m_nIndex;
  int m_nRace;
  int m_nLevel;
  unsigned int m_dwAI;
  int m_nItemGroup;
  int m_nDropNum;
  int m_nRange;
  int m_nSight[2];
  int m_nExp;
  PROPERTY_BASE m_prtyBase;
  PROPERTY_PT m_prtyPt;
  int m_nMSpeed[2];
  int m_nAttackType;
  std::vector<QUESTITEMDROP,std::allocator<QUESTITEMDROP> > m_vecQuestItemDrop;
};


struct std::binary_function<CPlayer *,CPlayer *,bool>
{
  char dummy[1];
};


struct std::less<CPlayer *>
{
  std::binary_function<CPlayer *,CPlayer *,bool> baseclass_0;
};


struct std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0>
{
  std::less<CPlayer *> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >
{
  std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<CPlayer * const,int> >
{
  char dummy[1];
};


struct std::allocator<std::pair<CPlayer * const,int> >
{
  std::_Allocator_base<std::pair<CPlayer * const,int> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> > baseclass_0;
  std::allocator<std::pair<CPlayer * const,int> > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node *_Right;
  std::pair<CPlayer * const,int> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<CPlayer * const,int>
{
  CPlayer *const first;
  int second;
};


struct std::_Tree<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> > >
{
  std::_Tree<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> > baseclass_0;
};


struct std::binary_function<CParty *,CParty *,bool>
{
  char dummy[1];
};


struct std::less<CParty *>
{
  std::binary_function<CParty *,CParty *,bool> baseclass_0;
};


struct std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0>
{
  std::less<CParty *> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >
{
  std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<CParty * const,int> >
{
  char dummy[1];
};


struct std::allocator<std::pair<CParty * const,int> >
{
  std::_Allocator_base<std::pair<CParty * const,int> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> > baseclass_0;
  std::allocator<std::pair<CParty * const,int> > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node *_Right;
  std::pair<CParty * const,int> _Myval;
  char _Color;
  char _Isnil;
};


struct std::_Allocator_base<CPlayer *>
{
  char dummy[1];
};


struct std::allocator<CPlayer *>
{
  std::_Allocator_base<CPlayer *> baseclass_0;
};


struct std::_Vector_val<CPlayer *,std::allocator<CPlayer *> >
{
  std::allocator<CPlayer *> _Alval;
};


struct std::vector<CPlayer *,std::allocator<CPlayer *> >
{
  std::_Vector_val<CPlayer *,std::allocator<CPlayer *> > baseclass_0;
  CPlayer **_Myfirst;
  CPlayer **_Mylast;
  CPlayer **_Myend;
};


struct CParty
{
  CIOObject baseclass_0;
  int m_nId;
  CPlayer *m_pHead;
  int m_nTopLevel;
  int m_nLevelSum;
  int m_bEnd;
  std::vector<CPlayer *,std::allocator<CPlayer *> > m_vecParty;
  CIOCriticalSection m_lock;
};


struct std::pair<CParty * const,int>
{
  CParty *const first;
  int second;
};


struct std::_Tree<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> > >
{
  std::_Tree<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> > baseclass_0;
};


struct CMonster
{
  CChar baseclass_0;
  CInitMonster *m_pInit;
  int m_nArea;
  tagRECT m_rtArea;
  tagPOINT m_ptPReturn;
  unsigned int m_dwAI;
  int m_nSight[2];
  int m_nRoam;
  int m_nMoveType;
  int m_bSleep;
  CChar *m_pTarget;
  unsigned int m_dwNextAction;
  unsigned int m_dwResetHP;
  unsigned int m_dwNextMove;
  std::map<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> > > m_mapHostility;
  CIOCriticalSection m_lockHostility;
  int m_nAllHostility;
  int m_nMaxHostility;
  std::map<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> > > m_mapExpParty;
  CFindPath m_findpath;
  int m_bRest;
};


struct CFindPath
{
  CMonster *m_pOwner;
  CSMap *m_pMap;
  CFindPath::NODE *m_pNext;
  CFindPath::NODE *m_pNextBest;
  CFindPath::NODE *m_pCurrent;
  tagPOINT m_ptSPixel;
  tagPOINT m_ptEPixel;
  int m_nPowRange;
};


struct CGenMonster
{
  CBase baseclass_0;
  int m_nIndex;
  int m_nMap;
  int m_nArea;
  int m_nMax;
  int m_nLive;
  tagRECT m_rtGen;
  CSMap *m_pMap;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<CPlayer * const,int>,int,std::pair<CPlayer * const,int> const *,std::pair<CPlayer * const,int> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<CPlayer * const,int>,int,std::pair<CPlayer * const,int> const *,std::pair<CPlayer * const,int> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<CPlayer * const,int>,int,std::pair<CPlayer * const,int> const *,std::pair<CPlayer * const,int> const &> baseclass_0;
};


union $08A00FF867E6C3D55F199E51FCED64A3
{
  std::_Bidit<std::pair<CPlayer * const,int>,int,std::pair<CPlayer * const,int> const *,std::pair<CPlayer * const,int> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::const_iterator
{
  $08A00FF867E6C3D55F199E51FCED64A3 ___u0;
};


struct std::_Tree<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::const_iterator baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<CParty * const,int>,int,std::pair<CParty * const,int> const *,std::pair<CParty * const,int> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<CParty * const,int>,int,std::pair<CParty * const,int> const *,std::pair<CParty * const,int> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<CParty * const,int>,int,std::pair<CParty * const,int> const *,std::pair<CParty * const,int> const &> baseclass_0;
};


union $CD892C8868ECA4BE50AA6C333AD872B0
{
  std::_Bidit<std::pair<CParty * const,int>,int,std::pair<CParty * const,int> const *,std::pair<CParty * const,int> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::const_iterator
{
  $CD892C8868ECA4BE50AA6C333AD872B0 ___u0;
};


struct std::_Tree<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::const_iterator baseclass_0;
};


struct std::allocator<std::pair<CPlayer * const,int> >::rebind<std::pair<CPlayer * const,int> >
{
  char dummy[1];
};


struct std::allocator<std::pair<CPlayer * const,int> >::rebind<std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<CPlayer * const,int> >::rebind<std::_Tree_nod<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<CPlayer * const,int> >::rebind<CPlayer *>
{
  char dummy[1];
};


struct std::allocator<std::pair<CPlayer * const,int> >::rebind<char>
{
  char dummy[1];
};


struct std::pair<std::_Tree<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::iterator first;
  bool second;
};


struct std::pair<std::_Tree<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::iterator,std::_Tree<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::i
{
  std::_Tree<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::iterator first;
  std::_Tree<std::_Tmap_traits<CPlayer *,int,std::less<CPlayer *>,std::allocator<std::pair<CPlayer * const,int> >,0> >::iterator second;
};


struct std::allocator<std::pair<CParty * const,int> >::rebind<std::pair<CParty * const,int> >
{
  char dummy[1];
};


struct std::allocator<std::pair<CParty * const,int> >::rebind<std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<CParty * const,int> >::rebind<std::_Tree_nod<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<CParty * const,int> >::rebind<CParty *>
{
  char dummy[1];
};


struct std::allocator<std::pair<CParty * const,int> >::rebind<char>
{
  char dummy[1];
};


struct std::pair<std::_Tree<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<CParty *,int,std::less<CParty *>,std::allocator<std::pair<CParty * const,int> >,0> >::iterator first;
  bool second;
};


struct std::_Allocator_base<CParty *>
{
  char dummy[1];
};


struct std::allocator<CParty *>
{
  std::_Allocator_base<CParty *> baseclass_0;
};


struct CInitNPC
{
  CBase baseclass_0;
  int m_nKind;
  int m_nMoveType;
};


struct std::_Vector_val<int,std::allocator<int> >
{
  std::allocator<int> _Alval;
};


struct std::vector<int,std::allocator<int> >
{
  std::_Vector_val<int,std::allocator<int> > baseclass_0;
  int *_Myfirst;
  int *_Mylast;
  int *_Myend;
};


struct std::iterator<std::random_access_iterator_tag,int,int,int const *,int const &>
{
  char dummy[1];
};


struct std::_Ranit<int,int,int const *,int const &>
{
  std::iterator<std::random_access_iterator_tag,int,int,int const *,int const &> baseclass_0;
};


union $F47E93C4B5FDAE29650850AA0B0F58EC
{
  std::_Ranit<int,int,int const *,int const &> baseclass_0;
  int *_Myptr;
};


struct std::vector<int,std::allocator<int> >::const_iterator
{
  $F47E93C4B5FDAE29650850AA0B0F58EC ___u0;
};


struct std::vector<int,std::allocator<int> >::iterator
{
  std::vector<int,std::allocator<int> >::const_iterator baseclass_0;
};


struct CGenNPC
{
  CBase baseclass_0;
  int m_nIndex;
  int m_nKind;
  int m_nShape;
  int m_nHtml;
  unsigned int m_dwQuestKey;
  int m_nMap;
  CSMap *m_pMap;
  tagPOINT m_ptPixel;
  int m_nZ;
  int m_nDir;
};


struct CNPC
{
  CChar baseclass_0;
  CInitNPC *m_pInit;
  int m_nIndex;
  int m_nShape;
  int m_nHtml;
  unsigned int m_dwQuestKey;
};


struct CNPCInformant
{
  CNPC baseclass_0;
};


struct CNPCGuard
{
  CNPC baseclass_0;
};


struct CIOServer
{
  CIOObject baseclass_0;
  unsigned int m_hSocket;
  void *m_hAcceptEvent;
};


struct std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >
{
  std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CSocket *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CSocket *> >
{
  std::_Allocator_base<std::pair<int const ,CSocket *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CSocket *> > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node *_Right;
  std::pair<int const ,CSocket *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<int const ,CSocket *>
{
  const int first;
  CSocket *second;
};


struct std::_Tree<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> > >
{
  std::_Tree<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> > baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CSocket *>,int,std::pair<int const ,CSocket *> const *,std::pair<int const ,CSocket *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CSocket *>,int,std::pair<int const ,CSocket *> const *,std::pair<int const ,CSocket *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CSocket *>,int,std::pair<int const ,CSocket *> const *,std::pair<int const ,CSocket *> const &> baseclass_0;
};


union $7CD298727CBA4295BC58ECA347861757
{
  std::_Bidit<std::pair<int const ,CSocket *>,int,std::pair<int const ,CSocket *> const *,std::pair<int const ,CSocket *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::const_iterator
{
  $7CD298727CBA4295BC58ECA347861757 ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::const_iterator baseclass_0;
};


struct std::allocator<std::pair<int const ,CSocket *> >::rebind<std::pair<int const ,CSocket *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CSocket *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CSocket *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CSocket *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CSocket *> >::rebind<char>
{
  char dummy[1];
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::iterator first;
  bool second;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::iterator,std::_Tree<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::iterator>
{
  std::_Tree<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::iterator first;
  std::_Tree<std::_Tmap_traits<int,CSocket *,std::less<int>,std::allocator<std::pair<int const ,CSocket *> >,0> >::iterator second;
};


struct CServer
{
  CIOServer baseclass_0;
};


struct std::allocator<int>::rebind<int>
{
  char dummy[1];
};


struct PACKET
{
  unsigned __int16 wSize;
  char byType;
  char data[];
};


struct CInitMap
{
  CBase baseclass_0;
  int m_nIndex;
  int m_nKind;
  int m_nX;
  int m_nY;
  char m_szPath[129];
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CSMap *>,int,std::pair<int const ,CSMap *> const *,std::pair<int const ,CSMap *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CSMap *>,int,std::pair<int const ,CSMap *> const *,std::pair<int const ,CSMap *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CSMap *>,int,std::pair<int const ,CSMap *> const *,std::pair<int const ,CSMap *> const &> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node *_Right;
  std::pair<int const ,CSMap *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<int const ,CSMap *>
{
  const int first;
  CSMap *second;
};


union $2920E017C28C3AEBF56162FD18ECC1FB
{
  std::_Bidit<std::pair<int const ,CSMap *>,int,std::pair<int const ,CSMap *> const *,std::pair<int const ,CSMap *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::const_iterator
{
  $2920E017C28C3AEBF56162FD18ECC1FB ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::const_iterator baseclass_0;
};


struct std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >
{
  std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CSMap *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CSMap *> >
{
  std::_Allocator_base<std::pair<int const ,CSMap *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CSMap *> > _Alval;
};


struct std::_Tree<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> > >
{
  std::_Tree<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> > baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::iterator first;
  bool second;
};


struct std::allocator<std::pair<int const ,CSMap *> >::rebind<std::pair<int const ,CSMap *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CSMap *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CSMap *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CSMap *,std::less<int>,std::allocator<std::pair<int const ,CSMap *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CSMap *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CSMap *> >::rebind<char>
{
  char dummy[1];
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<unsigned long const ,CSkill *>,int,std::pair<unsigned long const ,CSkill *> const *,std::pair<unsigned long const ,CSkill *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<unsigned long const ,CSkill *>,int,std::pair<unsigned long const ,CSkill *> const *,std::pair<unsigned long const ,CSkill *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<unsigned long const ,CSkill *>,int,std::pair<unsigned long const ,CSkill *> const *,std::pair<unsigned long const ,CSkill *> const &> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node *_Right;
  std::pair<unsigned long const ,CSkill *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<unsigned long const ,CSkill *>
{
  const unsigned int first;
  CSkill *second;
};


union $F21F370D29495E41D21F1CDBEAEC3366
{
  std::_Bidit<std::pair<unsigned long const ,CSkill *>,int,std::pair<unsigned long const ,CSkill *> const *,std::pair<unsigned long const ,CSkill *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::const_iterator
{
  $F21F370D29495E41D21F1CDBEAEC3366 ___u0;
};


struct std::_Tree<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::const_iterator baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::iterator first;
  bool second;
};


struct std::binary_function<unsigned long,unsigned long,bool>
{
  char dummy[1];
};


struct std::less<unsigned long>
{
  std::binary_function<unsigned long,unsigned long,bool> baseclass_0;
};


struct std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0>
{
  std::less<unsigned long> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >
{
  std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<unsigned long const ,CSkill *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<unsigned long const ,CSkill *> >
{
  std::_Allocator_base<std::pair<unsigned long const ,CSkill *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> > baseclass_0;
  std::allocator<std::pair<unsigned long const ,CSkill *> > _Alval;
};


struct std::_Tree<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> > >
{
  std::_Tree<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> > baseclass_0;
};


struct std::allocator<std::pair<unsigned long const ,CSkill *> >::rebind<std::pair<unsigned long const ,CSkill *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<unsigned long const ,CSkill *> >::rebind<std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<unsigned long const ,CSkill *> >::rebind<std::_Tree_nod<std::_Tmap_traits<unsigned long,CSkill *,std::less<unsigned long>,std::allocator<std::pair<unsigned long const ,CSkill *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<unsigned long const ,CSkill *> >::rebind<unsigned long>
{
  char dummy[1];
};


struct std::allocator<std::pair<unsigned long const ,CSkill *> >::rebind<char>
{
  char dummy[1];
};


struct std::_Allocator_base<unsigned long>
{
  char dummy[1];
};


struct std::allocator<unsigned long>
{
  std::_Allocator_base<unsigned long> baseclass_0;
};


struct std::_Allocator_base<std::_List_nod<CCase *,std::allocator<CCase *> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_List_nod<CCase *,std::allocator<CCase *> >::_Node>
{
  std::_Allocator_base<std::_List_nod<CCase *,std::allocator<CCase *> >::_Node> baseclass_0;
};


struct std::_List_nod<CCase *,std::allocator<CCase *> >
{
  std::allocator<std::_List_nod<CCase *,std::allocator<CCase *> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_List_nod<CCase *,std::allocator<CCase *> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_List_nod<CCase *,std::allocator<CCase *> >::_Node *>
{
  std::_Allocator_base<std::_List_nod<CCase *,std::allocator<CCase *> >::_Node *> baseclass_0;
};


struct std::_List_ptr<CCase *,std::allocator<CCase *> >
{
  std::_List_nod<CCase *,std::allocator<CCase *> > baseclass_0;
  std::allocator<std::_List_nod<CCase *,std::allocator<CCase *> >::_Node *> _Alptr;
};


struct std::_Allocator_base<CCase *>
{
  char dummy[1];
};


struct std::allocator<CCase *>
{
  std::_Allocator_base<CCase *> baseclass_0;
};


struct std::_List_val<CCase *,std::allocator<CCase *> >
{
  std::_List_ptr<CCase *,std::allocator<CCase *> > baseclass_0;
  std::allocator<CCase *> _Alval;
};


struct std::_List_nod<CCase *,std::allocator<CCase *> >::_Node
{
  std::_List_nod<CCase *,std::allocator<CCase *> >::_Node *_Next;
  std::_List_nod<CCase *,std::allocator<CCase *> >::_Node *_Prev;
  CCase *_Myval;
};


struct std::_Allocator_base<std::_List_nod<CCondition *,std::allocator<CCondition *> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_List_nod<CCondition *,std::allocator<CCondition *> >::_Node>
{
  std::_Allocator_base<std::_List_nod<CCondition *,std::allocator<CCondition *> >::_Node> baseclass_0;
};


struct std::_List_nod<CCondition *,std::allocator<CCondition *> >
{
  std::allocator<std::_List_nod<CCondition *,std::allocator<CCondition *> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_List_nod<CCondition *,std::allocator<CCondition *> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_List_nod<CCondition *,std::allocator<CCondition *> >::_Node *>
{
  std::_Allocator_base<std::_List_nod<CCondition *,std::allocator<CCondition *> >::_Node *> baseclass_0;
};


struct std::_List_ptr<CCondition *,std::allocator<CCondition *> >
{
  std::_List_nod<CCondition *,std::allocator<CCondition *> > baseclass_0;
  std::allocator<std::_List_nod<CCondition *,std::allocator<CCondition *> >::_Node *> _Alptr;
};


struct std::_Allocator_base<CCondition *>
{
  char dummy[1];
};


struct std::allocator<CCondition *>
{
  std::_Allocator_base<CCondition *> baseclass_0;
};


struct std::_List_val<CCondition *,std::allocator<CCondition *> >
{
  std::_List_ptr<CCondition *,std::allocator<CCondition *> > baseclass_0;
  std::allocator<CCondition *> _Alval;
};


struct std::_List_nod<CCondition *,std::allocator<CCondition *> >::_Node
{
  std::_List_nod<CCondition *,std::allocator<CCondition *> >::_Node *_Next;
  std::_List_nod<CCondition *,std::allocator<CCondition *> >::_Node *_Prev;
  CCondition *_Myval;
};


struct CCondition
{
  CConditionVtbl *vfptr;
  int m_nValue;
};


struct CConditionVtbl
{
  void *(__thiscall *__vecDelDtor)(CCondition *this, unsigned int);
  int (__thiscall *IsMeet)(CCondition *this, CPlayer *);
};


struct std::list<CCondition *,std::allocator<CCondition *> >
{
  std::_List_val<CCondition *,std::allocator<CCondition *> > baseclass_0;
  std::_List_nod<CCondition *,std::allocator<CCondition *> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::_Allocator_base<std::_List_nod<CAction *,std::allocator<CAction *> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_List_nod<CAction *,std::allocator<CAction *> >::_Node>
{
  std::_Allocator_base<std::_List_nod<CAction *,std::allocator<CAction *> >::_Node> baseclass_0;
};


struct std::_List_nod<CAction *,std::allocator<CAction *> >
{
  std::allocator<std::_List_nod<CAction *,std::allocator<CAction *> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_List_nod<CAction *,std::allocator<CAction *> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_List_nod<CAction *,std::allocator<CAction *> >::_Node *>
{
  std::_Allocator_base<std::_List_nod<CAction *,std::allocator<CAction *> >::_Node *> baseclass_0;
};


struct std::_List_ptr<CAction *,std::allocator<CAction *> >
{
  std::_List_nod<CAction *,std::allocator<CAction *> > baseclass_0;
  std::allocator<std::_List_nod<CAction *,std::allocator<CAction *> >::_Node *> _Alptr;
};


struct std::_Allocator_base<CAction *>
{
  char dummy[1];
};


struct std::allocator<CAction *>
{
  std::_Allocator_base<CAction *> baseclass_0;
};


struct std::_List_val<CAction *,std::allocator<CAction *> >
{
  std::_List_ptr<CAction *,std::allocator<CAction *> > baseclass_0;
  std::allocator<CAction *> _Alval;
};


struct std::_List_nod<CAction *,std::allocator<CAction *> >::_Node
{
  std::_List_nod<CAction *,std::allocator<CAction *> >::_Node *_Next;
  std::_List_nod<CAction *,std::allocator<CAction *> >::_Node *_Prev;
  CAction *_Myval;
};


struct CAction
{
  CActionVtbl *vfptr;
  int m_nValue;
};


struct CActionVtbl
{
  void *(__thiscall *__vecDelDtor)(CAction *this, unsigned int);
  void (__thiscall *Action)(CAction *this, CPlayer *);
};


struct std::list<CAction *,std::allocator<CAction *> >
{
  std::_List_val<CAction *,std::allocator<CAction *> > baseclass_0;
  std::_List_nod<CAction *,std::allocator<CAction *> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct CCase
{
  std::list<CCondition *,std::allocator<CCondition *> > m_listCond;
  std::list<CAction *,std::allocator<CAction *> > m_listAction;
};


struct std::list<CCase *,std::allocator<CCase *> >
{
  std::_List_val<CCase *,std::allocator<CCase *> > baseclass_0;
  std::_List_nod<CCase *,std::allocator<CCase *> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct CQuest
{
  CBase baseclass_0;
  unsigned int m_dwKey;
  int m_bLinked;
  std::list<CCase *,std::allocator<CCase *> > m_listCase;
};


struct CReward
{
  CRewardVtbl *vfptr;
  int m_nValue;
};


struct CRewardVtbl
{
  void (__thiscall *Reward)(CReward *this, CPlayer *);
};


struct std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >
{
  std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CQuest *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CQuest *> >
{
  std::_Allocator_base<std::pair<int const ,CQuest *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CQuest *> > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node *_Right;
  std::pair<int const ,CQuest *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<int const ,CQuest *>
{
  const int first;
  CQuest *second;
};


struct std::_Tree<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> > >
{
  std::_Tree<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> > baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CQuest *>,int,std::pair<int const ,CQuest *> const *,std::pair<int const ,CQuest *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CQuest *>,int,std::pair<int const ,CQuest *> const *,std::pair<int const ,CQuest *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CQuest *>,int,std::pair<int const ,CQuest *> const *,std::pair<int const ,CQuest *> const &> baseclass_0;
};


union $7CAE5101E96C8BD157B77F34AE42B02B
{
  std::_Bidit<std::pair<int const ,CQuest *>,int,std::pair<int const ,CQuest *> const *,std::pair<int const ,CQuest *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::const_iterator
{
  $7CAE5101E96C8BD157B77F34AE42B02B ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::const_iterator baseclass_0;
};


struct std::_Allocator_base<QITEM>
{
  char dummy[1];
};


struct std::allocator<QITEM>
{
  std::_Allocator_base<QITEM> baseclass_0;
};


struct std::_Vector_val<QITEM,std::allocator<QITEM> >
{
  std::allocator<QITEM> _Alval;
};


struct QITEM
{
  int nIndex;
  int nPrefix;
  int nNum;
};


struct std::vector<QITEM,std::allocator<QITEM> >
{
  std::_Vector_val<QITEM,std::allocator<QITEM> > baseclass_0;
  QITEM *_Myfirst;
  QITEM *_Mylast;
  QITEM *_Myend;
};


struct CCondClass
{
  CCondition baseclass_0;
};


struct CCondLevel
{
  CCondition baseclass_0;
};


struct CCondSpecialty
{
  CCondition baseclass_0;
};


struct std::_Allocator_base<QUESTITEM>
{
  char dummy[1];
};


struct std::allocator<QUESTITEM>
{
  std::_Allocator_base<QUESTITEM> baseclass_0;
};


struct std::_Vector_val<QUESTITEM,std::allocator<QUESTITEM> >
{
  std::allocator<QUESTITEM> _Alval;
};


struct QUESTITEM
{
  int nIndex;
  int nPrefix;
  int nNum;
  int bInsert;
};


struct std::vector<QUESTITEM,std::allocator<QUESTITEM> >
{
  std::_Vector_val<QUESTITEM,std::allocator<QUESTITEM> > baseclass_0;
  QUESTITEM *_Myfirst;
  QUESTITEM *_Mylast;
  QUESTITEM *_Myend;
};


struct CCondItem
{
  CCondition baseclass_0;
  std::vector<QUESTITEM,std::allocator<QUESTITEM> > m_vecQItem;
};


struct CCondParty
{
  CCondition baseclass_0;
};


struct CCondQuest
{
  CCondition baseclass_0;
};


struct CRwdExp
{
  CReward baseclass_0;
};


struct CRwdItem
{
  CReward baseclass_0;
  std::vector<QITEM,std::allocator<QITEM> > m_vecQItem;
};


struct CRwdReputation
{
  CReward baseclass_0;
};


struct CRwdSUPoint
{
  CReward baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::iterator first;
  bool second;
};


struct std::_Vector_val<CCondition *,std::allocator<CCondition *> >
{
  std::allocator<CCondition *> _Alval;
};


struct std::vector<CCondition *,std::allocator<CCondition *> >
{
  std::_Vector_val<CCondition *,std::allocator<CCondition *> > baseclass_0;
  CCondition **_Myfirst;
  CCondition **_Mylast;
  CCondition **_Myend;
};


struct std::_Allocator_base<CReward *>
{
  char dummy[1];
};


struct std::allocator<CReward *>
{
  std::_Allocator_base<CReward *> baseclass_0;
};


struct std::_Vector_val<CReward *,std::allocator<CReward *> >
{
  std::allocator<CReward *> _Alval;
};


struct std::vector<CReward *,std::allocator<CReward *> >
{
  std::_Vector_val<CReward *,std::allocator<CReward *> > baseclass_0;
  CReward **_Myfirst;
  CReward **_Mylast;
  CReward **_Myend;
};


struct std::allocator<std::pair<int const ,CQuest *> >::rebind<std::pair<int const ,CQuest *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CQuest *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CQuest *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CQuest *,std::less<int>,std::allocator<std::pair<int const ,CQuest *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CQuest *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CQuest *> >::rebind<char>
{
  char dummy[1];
};


struct std::iterator<std::random_access_iterator_tag,CCondition *,int,CCondition * const *,CCondition * const &>
{
  char dummy[1];
};


struct std::_Ranit<CCondition *,int,CCondition * const *,CCondition * const &>
{
  std::iterator<std::random_access_iterator_tag,CCondition *,int,CCondition * const *,CCondition * const &> baseclass_0;
};


union $56C5FDFB940159B0C6D942CBE5955883
{
  std::_Ranit<CCondition *,int,CCondition * const *,CCondition * const &> baseclass_0;
  CCondition **_Myptr;
};


struct std::vector<CCondition *,std::allocator<CCondition *> >::const_iterator
{
  $56C5FDFB940159B0C6D942CBE5955883 ___u0;
};


struct std::vector<CCondition *,std::allocator<CCondition *> >::iterator
{
  std::vector<CCondition *,std::allocator<CCondition *> >::const_iterator baseclass_0;
};


struct std::iterator<std::random_access_iterator_tag,CReward *,int,CReward * const *,CReward * const &>
{
  char dummy[1];
};


struct std::_Ranit<CReward *,int,CReward * const *,CReward * const &>
{
  std::iterator<std::random_access_iterator_tag,CReward *,int,CReward * const *,CReward * const &> baseclass_0;
};


union $42F065A2C5934D6160313E236CD40307
{
  std::_Ranit<CReward *,int,CReward * const *,CReward * const &> baseclass_0;
  CReward **_Myptr;
};


struct std::vector<CReward *,std::allocator<CReward *> >::const_iterator
{
  $42F065A2C5934D6160313E236CD40307 ___u0;
};


struct std::vector<CReward *,std::allocator<CReward *> >::iterator
{
  std::vector<CReward *,std::allocator<CReward *> >::const_iterator baseclass_0;
};


struct CConfig
{
  char m_szSymbol[512];
  _iobuf *m_fp;
  int m_nLine;
  lisp::var m_root;
  Token m_token;
};


struct CObjectDB
{
  CConfig baseclass_0;
  const char *m_pszFileName;
};


struct std::allocator<QITEM>::rebind<QITEM>
{
  char dummy[1];
};


struct std::allocator<CCondition *>::rebind<CCondition *>
{
  char dummy[1];
};


struct std::allocator<CReward *>::rebind<CReward *>
{
  char dummy[1];
};


struct std::iterator<std::random_access_iterator_tag,CPlayer *,int,CPlayer * const *,CPlayer * const &>
{
  char dummy[1];
};


struct std::_Ranit<CPlayer *,int,CPlayer * const *,CPlayer * const &>
{
  std::iterator<std::random_access_iterator_tag,CPlayer *,int,CPlayer * const *,CPlayer * const &> baseclass_0;
};


union $EFCB685E393A4C8173B4F9126F17EDAE
{
  std::_Ranit<CPlayer *,int,CPlayer * const *,CPlayer * const &> baseclass_0;
  CPlayer **_Myptr;
};


struct std::vector<CPlayer *,std::allocator<CPlayer *> >::const_iterator
{
  $EFCB685E393A4C8173B4F9126F17EDAE ___u0;
};


struct std::vector<CPlayer *,std::allocator<CPlayer *> >::iterator
{
  std::vector<CPlayer *,std::allocator<CPlayer *> >::const_iterator baseclass_0;
};


struct std::allocator<CPlayer *>::rebind<CPlayer *>
{
  char dummy[1];
};


struct CCalendar
{
  CIOObject baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CParty *>,int,std::pair<int const ,CParty *> const *,std::pair<int const ,CParty *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CParty *>,int,std::pair<int const ,CParty *> const *,std::pair<int const ,CParty *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CParty *>,int,std::pair<int const ,CParty *> const *,std::pair<int const ,CParty *> const &> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node *_Right;
  std::pair<int const ,CParty *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<int const ,CParty *>
{
  const int first;
  CParty *second;
};


union $6E2D6E7AD65BDB303D2AFC5529A15803
{
  std::_Bidit<std::pair<int const ,CParty *>,int,std::pair<int const ,CParty *> const *,std::pair<int const ,CParty *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::const_iterator
{
  $6E2D6E7AD65BDB303D2AFC5529A15803 ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::const_iterator baseclass_0;
};


struct std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >
{
  std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CParty *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CParty *> >
{
  std::_Allocator_base<std::pair<int const ,CParty *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CParty *> > _Alval;
};


struct std::_Tree<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> > >
{
  std::_Tree<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> > baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::iterator first;
  bool second;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::iterator,std::_Tree<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::iterator>
{
  std::_Tree<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::iterator first;
  std::_Tree<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::iterator second;
};


struct std::allocator<std::pair<int const ,CParty *> >::rebind<std::pair<int const ,CParty *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CParty *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CParty *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CParty *,std::less<int>,std::allocator<std::pair<int const ,CParty *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CParty *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CParty *> >::rebind<char>
{
  char dummy[1];
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<char const * const,enum Symbol>,int,std::pair<char const * const,enum Symbol> const *,std::pair<char const * const,enum Symbol> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<char const * const,enum Symbol>,int,std::pair<char const * const,enum Symbol> const *,std::pair<char const * const,enum Symbol> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<char const * const,enum Symbol>,int,std::pair<char const * const,enum Symbol> const *,std::pair<char const * const,enum Symbol> const &> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node *_Right;
  std::pair<char const * const,enum Symbol> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<char const * const,enum Symbol>
{
  const char *const first;
  Symbol second;
};


union $577B2A27CAC0B8F444BD53A3A49C9BE7
{
  std::_Bidit<std::pair<char const * const,enum Symbol>,int,std::pair<char const * const,enum Symbol> const *,std::pair<char const * const,enum Symbol> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::const_iterator
{
  $577B2A27CAC0B8F444BD53A3A49C9BE7 ___u0;
};


struct std::_Tree<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::const_iterator baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::iterator first;
  bool second;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<char const * const,CBase *>,int,std::pair<char const * const,CBase *> const *,std::pair<char const * const,CBase *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<char const * const,CBase *>,int,std::pair<char const * const,CBase *> const *,std::pair<char const * const,CBase *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<char const * const,CBase *>,int,std::pair<char const * const,CBase *> const *,std::pair<char const * const,CBase *> const &> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node *_Right;
  std::pair<char const * const,CBase *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<char const * const,CBase *>
{
  const char *const first;
  CBase *second;
};


union $2BACABAAB22A0FCA16E29B1C04358922
{
  std::_Bidit<std::pair<char const * const,CBase *>,int,std::pair<char const * const,CBase *> const *,std::pair<char const * const,CBase *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::const_iterator
{
  $2BACABAAB22A0FCA16E29B1C04358922 ___u0;
};


struct std::_Tree<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::const_iterator baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::iterator first;
  bool second;
};


struct std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0>
{
  iless comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >
{
  std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<char const * const,CBase *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,CBase *> >
{
  std::_Allocator_base<std::pair<char const * const,CBase *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> > baseclass_0;
  std::allocator<std::pair<char const * const,CBase *> > _Alval;
};


struct std::_Tree<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> > >
{
  std::_Tree<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> > baseclass_0;
};


struct std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0>
{
  iless comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >
{
  std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<char const * const,enum Symbol> >
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,enum Symbol> >
{
  std::_Allocator_base<std::pair<char const * const,enum Symbol> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> > baseclass_0;
  std::allocator<std::pair<char const * const,enum Symbol> > _Alval;
};


struct std::_Tree<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> > >
{
  std::_Tree<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> > baseclass_0;
};


struct std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >
{
  std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CGroup *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGroup *> >
{
  std::_Allocator_base<std::pair<int const ,CGroup *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CGroup *> > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node *_Right;
  std::pair<int const ,CGroup *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<int const ,CGroup *>
{
  const int first;
  CGroup *second;
};


struct std::_Tree<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> > >
{
  std::_Tree<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> > baseclass_0;
};


struct std::iterator<std::random_access_iterator_tag,ITEMDROPINFO,int,ITEMDROPINFO const *,ITEMDROPINFO const &>
{
  char dummy[1];
};


struct std::_Ranit<ITEMDROPINFO,int,ITEMDROPINFO const *,ITEMDROPINFO const &>
{
  std::iterator<std::random_access_iterator_tag,ITEMDROPINFO,int,ITEMDROPINFO const *,ITEMDROPINFO const &> baseclass_0;
};


union $AA03A35C09BC8EE584557E79AC47D07D
{
  std::_Ranit<ITEMDROPINFO,int,ITEMDROPINFO const *,ITEMDROPINFO const &> baseclass_0;
  ITEMDROPINFO *_Myptr;
};


struct std::vector<ITEMDROPINFO,std::allocator<ITEMDROPINFO> >::const_iterator
{
  $AA03A35C09BC8EE584557E79AC47D07D ___u0;
};


struct std::vector<ITEMDROPINFO,std::allocator<ITEMDROPINFO> >::iterator
{
  std::vector<ITEMDROPINFO,std::allocator<ITEMDROPINFO> >::const_iterator baseclass_0;
};


struct std::iterator<std::random_access_iterator_tag,ITEMGROUP,int,ITEMGROUP const *,ITEMGROUP const &>
{
  char dummy[1];
};


struct std::_Ranit<ITEMGROUP,int,ITEMGROUP const *,ITEMGROUP const &>
{
  std::iterator<std::random_access_iterator_tag,ITEMGROUP,int,ITEMGROUP const *,ITEMGROUP const &> baseclass_0;
};


union $6C7952B8744F7B4E0FC8FCC853290591
{
  std::_Ranit<ITEMGROUP,int,ITEMGROUP const *,ITEMGROUP const &> baseclass_0;
  ITEMGROUP *_Myptr;
};


struct std::vector<ITEMGROUP,std::allocator<ITEMGROUP> >::const_iterator
{
  $6C7952B8744F7B4E0FC8FCC853290591 ___u0;
};


struct std::vector<ITEMGROUP,std::allocator<ITEMGROUP> >::iterator
{
  std::vector<ITEMGROUP,std::allocator<ITEMGROUP> >::const_iterator baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CGroup *>,int,std::pair<int const ,CGroup *> const *,std::pair<int const ,CGroup *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CGroup *>,int,std::pair<int const ,CGroup *> const *,std::pair<int const ,CGroup *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CGroup *>,int,std::pair<int const ,CGroup *> const *,std::pair<int const ,CGroup *> const &> baseclass_0;
};


union $9A0570B3091E1387F03827A9AB857E6A
{
  std::_Bidit<std::pair<int const ,CGroup *>,int,std::pair<int const ,CGroup *> const *,std::pair<int const ,CGroup *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::const_iterator
{
  $9A0570B3091E1387F03827A9AB857E6A ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::const_iterator baseclass_0;
};


struct std::allocator<std::pair<int const ,CGroup *> >::rebind<std::pair<int const ,CGroup *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGroup *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGroup *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGroup *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGroup *> >::rebind<char>
{
  char dummy[1];
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CGroup *,std::less<int>,std::allocator<std::pair<int const ,CGroup *> >,0> >::iterator first;
  bool second;
};


struct std::allocator<std::pair<char const * const,enum Symbol> >::rebind<std::pair<char const * const,enum Symbol> >
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,enum Symbol> >::rebind<std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,enum Symbol> >::rebind<std::_Tree_nod<std::_Tmap_traits<char const *,enum Symbol,iless,std::allocator<std::pair<char const * const,enum Symbol> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,enum Symbol> >::rebind<char const *>
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,enum Symbol> >::rebind<char>
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,CBase *> >::rebind<std::pair<char const * const,CBase *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,CBase *> >::rebind<std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,CBase *> >::rebind<std::_Tree_nod<std::_Tmap_traits<char const *,CBase *,iless,std::allocator<std::pair<char const * const,CBase *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,CBase *> >::rebind<char const *>
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,CBase *> >::rebind<char>
{
  char dummy[1];
};


struct std::allocator<ITEMDROPINFO>::rebind<ITEMDROPINFO>
{
  char dummy[1];
};


struct std::allocator<ITEMGROUP>::rebind<ITEMGROUP>
{
  char dummy[1];
};


struct std::_Allocator_base<char const *>
{
  char dummy[1];
};


struct std::allocator<char const *>
{
  std::_Allocator_base<char const *> baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CInitNPC *>,int,std::pair<int const ,CInitNPC *> const *,std::pair<int const ,CInitNPC *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CInitNPC *>,int,std::pair<int const ,CInitNPC *> const *,std::pair<int const ,CInitNPC *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CInitNPC *>,int,std::pair<int const ,CInitNPC *> const *,std::pair<int const ,CInitNPC *> const &> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node *_Right;
  std::pair<int const ,CInitNPC *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<int const ,CInitNPC *>
{
  const int first;
  CInitNPC *second;
};


union $2E97A7DE758B3D71D0DD99DCE523BCDF
{
  std::_Bidit<std::pair<int const ,CInitNPC *>,int,std::pair<int const ,CInitNPC *> const *,std::pair<int const ,CInitNPC *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::const_iterator
{
  $2E97A7DE758B3D71D0DD99DCE523BCDF ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::const_iterator baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::iterator first;
  bool second;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CGenNPC *>,int,std::pair<int const ,CGenNPC *> const *,std::pair<int const ,CGenNPC *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CGenNPC *>,int,std::pair<int const ,CGenNPC *> const *,std::pair<int const ,CGenNPC *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CGenNPC *>,int,std::pair<int const ,CGenNPC *> const *,std::pair<int const ,CGenNPC *> const &> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node *_Right;
  std::pair<int const ,CGenNPC *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<int const ,CGenNPC *>
{
  const int first;
  CGenNPC *second;
};


union $6F8F63C316DD941F5CA9127C9EB90AD6
{
  std::_Bidit<std::pair<int const ,CGenNPC *>,int,std::pair<int const ,CGenNPC *> const *,std::pair<int const ,CGenNPC *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::const_iterator
{
  $6F8F63C316DD941F5CA9127C9EB90AD6 ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::const_iterator baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::iterator first;
  bool second;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CNPC *>,int,std::pair<int const ,CNPC *> const *,std::pair<int const ,CNPC *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CNPC *>,int,std::pair<int const ,CNPC *> const *,std::pair<int const ,CNPC *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CNPC *>,int,std::pair<int const ,CNPC *> const *,std::pair<int const ,CNPC *> const &> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node *_Right;
  std::pair<int const ,CNPC *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<int const ,CNPC *>
{
  const int first;
  CNPC *second;
};


union $3A5FF0C5C328027688909E14C924AE75
{
  std::_Bidit<std::pair<int const ,CNPC *>,int,std::pair<int const ,CNPC *> const *,std::pair<int const ,CNPC *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::const_iterator
{
  $3A5FF0C5C328027688909E14C924AE75 ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::const_iterator baseclass_0;
};


struct CNPCMerchant
{
  CNPC baseclass_0;
};


struct std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >
{
  std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CNPC *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CNPC *> >
{
  std::_Allocator_base<std::pair<int const ,CNPC *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CNPC *> > _Alval;
};


struct std::_Tree<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> > >
{
  std::_Tree<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> > baseclass_0;
};


struct std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >
{
  std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CInitNPC *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CInitNPC *> >
{
  std::_Allocator_base<std::pair<int const ,CInitNPC *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CInitNPC *> > _Alval;
};


struct std::_Tree<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> > >
{
  std::_Tree<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> > baseclass_0;
};


struct std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >
{
  std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CGenNPC *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGenNPC *> >
{
  std::_Allocator_base<std::pair<int const ,CGenNPC *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CGenNPC *> > _Alval;
};


struct std::_Tree<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> > >
{
  std::_Tree<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> > baseclass_0;
};


struct std::allocator<std::pair<int const ,CInitNPC *> >::rebind<std::pair<int const ,CInitNPC *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CInitNPC *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CInitNPC *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CInitNPC *,std::less<int>,std::allocator<std::pair<int const ,CInitNPC *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CInitNPC *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CInitNPC *> >::rebind<char>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGenNPC *> >::rebind<std::pair<int const ,CGenNPC *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGenNPC *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGenNPC *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CGenNPC *,std::less<int>,std::allocator<std::pair<int const ,CGenNPC *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGenNPC *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGenNPC *> >::rebind<char>
{
  char dummy[1];
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::iterator first;
  bool second;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::iterator,std::_Tree<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::iterator>
{
  std::_Tree<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::iterator first;
  std::_Tree<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::iterator second;
};


struct std::allocator<std::pair<int const ,CNPC *> >::rebind<std::pair<int const ,CNPC *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CNPC *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CNPC *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CNPC *,std::less<int>,std::allocator<std::pair<int const ,CNPC *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CNPC *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CNPC *> >::rebind<char>
{
  char dummy[1];
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CInitMonster *>,int,std::pair<int const ,CInitMonster *> const *,std::pair<int const ,CInitMonster *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CInitMonster *>,int,std::pair<int const ,CInitMonster *> const *,std::pair<int const ,CInitMonster *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CInitMonster *>,int,std::pair<int const ,CInitMonster *> const *,std::pair<int const ,CInitMonster *> const &> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node *_Right;
  std::pair<int const ,CInitMonster *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<int const ,CInitMonster *>
{
  const int first;
  CInitMonster *second;
};


union $6EFF7A0B65CA96F5E5FD95B324FAF0C5
{
  std::_Bidit<std::pair<int const ,CInitMonster *>,int,std::pair<int const ,CInitMonster *> const *,std::pair<int const ,CInitMonster *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::const_iterator
{
  $6EFF7A0B65CA96F5E5FD95B324FAF0C5 ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::const_iterator baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::iterator first;
  bool second;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CGenMonster *>,int,std::pair<int const ,CGenMonster *> const *,std::pair<int const ,CGenMonster *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CGenMonster *>,int,std::pair<int const ,CGenMonster *> const *,std::pair<int const ,CGenMonster *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CGenMonster *>,int,std::pair<int const ,CGenMonster *> const *,std::pair<int const ,CGenMonster *> const &> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node *_Right;
  std::pair<int const ,CGenMonster *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<int const ,CGenMonster *>
{
  const int first;
  CGenMonster *second;
};


union $608CBD302818D4196354CA6BC4D4F96D
{
  std::_Bidit<std::pair<int const ,CGenMonster *>,int,std::pair<int const ,CGenMonster *> const *,std::pair<int const ,CGenMonster *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::const_iterator
{
  $608CBD302818D4196354CA6BC4D4F96D ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::const_iterator baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::iterator first;
  bool second;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CMonster *>,int,std::pair<int const ,CMonster *> const *,std::pair<int const ,CMonster *> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,CMonster *>,int,std::pair<int const ,CMonster *> const *,std::pair<int const ,CMonster *> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,CMonster *>,int,std::pair<int const ,CMonster *> const *,std::pair<int const ,CMonster *> const &> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node *_Right;
  std::pair<int const ,CMonster *> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<int const ,CMonster *>
{
  const int first;
  CMonster *second;
};


union $B2C82350D242CFE226F6AF069321A0FB
{
  std::_Bidit<std::pair<int const ,CMonster *>,int,std::pair<int const ,CMonster *> const *,std::pair<int const ,CMonster *> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::const_iterator
{
  $B2C82350D242CFE226F6AF069321A0FB ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::const_iterator baseclass_0;
};


struct std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >
{
  std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CInitMonster *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CInitMonster *> >
{
  std::_Allocator_base<std::pair<int const ,CInitMonster *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CInitMonster *> > _Alval;
};


struct std::_Tree<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> > >
{
  std::_Tree<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> > baseclass_0;
};


struct std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >
{
  std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CGenMonster *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGenMonster *> >
{
  std::_Allocator_base<std::pair<int const ,CGenMonster *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CGenMonster *> > _Alval;
};


struct std::_Tree<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> > >
{
  std::_Tree<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> > baseclass_0;
};


struct std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >
{
  std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,CMonster *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CMonster *> >
{
  std::_Allocator_base<std::pair<int const ,CMonster *> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,CMonster *> > _Alval;
};


struct std::_Tree<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> > >
{
  std::_Tree<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> > baseclass_0;
};


struct std::allocator<std::pair<int const ,CInitMonster *> >::rebind<std::pair<int const ,CInitMonster *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CInitMonster *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CInitMonster *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CInitMonster *,std::less<int>,std::allocator<std::pair<int const ,CInitMonster *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CInitMonster *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CInitMonster *> >::rebind<char>
{
  char dummy[1];
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::iterator first;
  bool second;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::iterator,std::_Tree<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::iterato
{
  std::_Tree<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::iterator first;
  std::_Tree<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::iterator second;
};


struct std::allocator<std::pair<int const ,CMonster *> >::rebind<std::pair<int const ,CMonster *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CMonster *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CMonster *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CMonster *,std::less<int>,std::allocator<std::pair<int const ,CMonster *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CMonster *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CMonster *> >::rebind<char>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGenMonster *> >::rebind<std::pair<int const ,CGenMonster *> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGenMonster *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGenMonster *> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,CGenMonster *,std::less<int>,std::allocator<std::pair<int const ,CGenMonster *> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGenMonster *> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,CGenMonster *> >::rebind<char>
{
  char dummy[1];
};


struct std::_Allocator_base<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >
{
  char dummy[1];
};


struct std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >
{
  std::_Allocator_base<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > baseclass_0;
};


struct std::_Vector_val<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >
{
  std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > _Alval;
};


struct std::vector<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >
{
  std::_Vector_val<std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > > > baseclass_0;
  std::basic_string<char,std::char_traits<char>,std::allocator<char> > *_Myfirst;
  std::basic_string<char,std::char_traits<char>,std::allocator<char> > *_Mylast;
  std::basic_string<char,std::char_traits<char>,std::allocator<char> > *_Myend;
};


struct std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >:
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >::_Node
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >: baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >
{
  std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >::_Node _Alnod;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >::_Node _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >
{
  std::_Allocator_base<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> > baseclass_0;
  std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >::_Node *_Right;
  std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > >
{
  const int first;
  std::basic_string<char,std::char_traits<char>,std::allocator<char> > second;
};


struct std::_Tree<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > > >
{
  std::_Tree<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> > baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > >,int,std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > const *,std::pair<int
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > >,int,std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > const *,std::pair<int const ,std::basic_string<char,std:
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > >,int,std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > const *,std::pair<int baseclass_0;
};


union $C28F6810FD7948040B0A72EE74AC9895
{
  std::_Bidit<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > >,int,std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > const *,std::pair<int const ,std::basic_string<char,std: baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >::const_iterator
{
  $C28F6810FD7948040B0A72EE74AC9895 ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >::const_iterator baseclass_0;
};


struct CLog::CInit
{
  char dummy[1];
};


struct CLog
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >::rebind<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >::rebind<std::_Tree_nod<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >::rebind<char>
{
  char dummy[1];
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,std::basic_string<char,std::char_traits<char>,std::allocator<char> >,std::less<int>,std::allocator<std::pair<int const ,std::basic_string<char,std::char_traits<char>,std::allocator<char> > > >,0> >::iterator first;
  bool second;
};


struct CMainConfig
{
  char dummy[1];
};


struct std::allocator<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >::rebind<std::basic_string<char,std::char_traits<char>,std::allocator<char> > >
{
  char dummy[1];
};


struct CItemWeapon
{
  CItem baseclass_0;
  int m_nMaxEnd;
  int m_nCurEnd;
  unsigned int m_dwSetGem;
  int m_nXAttack;
  int m_nXMagic;
  int m_nXDefense;
  int m_nXHit;
  int m_nXDodge;
};


struct CItemDefense
{
  CItem baseclass_0;
  int m_nMaxEnd;
  int m_nCurEnd;
  unsigned int m_dwSetGem;
  int m_nXAttack;
  int m_nXMagic;
  int m_nXDefense;
  int m_nXHit;
  int m_nXDodge;
};


struct CItemOrnament
{
  CItem baseclass_0;
};


struct CItemGeneral
{
  CItem baseclass_0;
};


struct std::_Allocator_base<CIOSocket::CIOTimer>
{
  char dummy[1];
};


struct std::allocator<CIOSocket::CIOTimer>
{
  std::_Allocator_base<CIOSocket::CIOTimer> baseclass_0;
};


struct std::_Vector_val<CIOSocket::CIOTimer,std::allocator<CIOSocket::CIOTimer> >
{
  std::allocator<CIOSocket::CIOTimer> _Alval;
};


struct std::vector<CIOSocket::CIOTimer,std::allocator<CIOSocket::CIOTimer> >
{
  std::_Vector_val<CIOSocket::CIOTimer,std::allocator<CIOSocket::CIOTimer> > baseclass_0;
  CIOSocket::CIOTimer *_Myfirst;
  CIOSocket::CIOTimer *_Mylast;
  CIOSocket::CIOTimer *_Myend;
};


struct std::binary_function<CIOSocket::CIOTimer,CIOSocket::CIOTimer,bool>
{
  char dummy[1];
};


struct std::less<CIOSocket::CIOTimer>
{
  std::binary_function<CIOSocket::CIOTimer,CIOSocket::CIOTimer,bool> baseclass_0;
};


struct std::priority_queue<CIOSocket::CIOTimer,std::vector<CIOSocket::CIOTimer,std::allocator<CIOSocket::CIOTimer> >,std::less<CIOSocket::CIOTimer> >
{
  std::vector<CIOSocket::CIOTimer,std::allocator<CIOSocket::CIOTimer> > c;
  std::less<CIOSocket::CIOTimer> comp;
};


struct std::iterator<std::random_access_iterator_tag,CIOSocket::CIOTimer,int,CIOSocket::CIOTimer const *,CIOSocket::CIOTimer const &>
{
  char dummy[1];
};


struct std::_Ranit<CIOSocket::CIOTimer,int,CIOSocket::CIOTimer const *,CIOSocket::CIOTimer const &>
{
  std::iterator<std::random_access_iterator_tag,CIOSocket::CIOTimer,int,CIOSocket::CIOTimer const *,CIOSocket::CIOTimer const &> baseclass_0;
};


union $1C10CACCED5C6D715C0D104641C8310F
{
  std::_Ranit<CIOSocket::CIOTimer,int,CIOSocket::CIOTimer const *,CIOSocket::CIOTimer const &> baseclass_0;
  CIOSocket::CIOTimer *_Myptr;
};


struct std::vector<CIOSocket::CIOTimer,std::allocator<CIOSocket::CIOTimer> >::const_iterator
{
  $1C10CACCED5C6D715C0D104641C8310F ___u0;
};


struct std::vector<CIOSocket::CIOTimer,std::allocator<CIOSocket::CIOTimer> >::iterator
{
  std::vector<CIOSocket::CIOTimer,std::allocator<CIOSocket::CIOTimer> >::const_iterator baseclass_0;
};


struct std::allocator<CIOSocket::CIOTimer>::rebind<CIOSocket::CIOTimer>
{
  char dummy[1];
};


struct GetExceptionDescription::__l2::ExceptionNames
{
  unsigned int ExceptionCode;
  char *ExceptionName;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<char const * const,int>,int,std::pair<char const * const,int> const *,std::pair<char const * const,int> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<char const * const,int>,int,std::pair<char const * const,int> const *,std::pair<char const * const,int> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<char const * const,int>,int,std::pair<char const * const,int> const *,std::pair<char const * const,int> const &> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node *_Right;
  std::pair<char const * const,int> _Myval;
  char _Color;
  char _Isnil;
};


struct std::pair<char const * const,int>
{
  const char *const first;
  int second;
};


union $8F82E7E8BF4077E7D8450227BD1E9D96
{
  std::_Bidit<std::pair<char const * const,int>,int,std::pair<char const * const,int> const *,std::pair<char const * const,int> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::const_iterator
{
  $8F82E7E8BF4077E7D8450227BD1E9D96 ___u0;
};


struct std::_Tree<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::const_iterator baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::iterator first;
  bool second;
};


struct std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0>
{
  iless comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >
{
  std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<char const * const,int> >
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,int> >
{
  std::_Allocator_base<std::pair<char const * const,int> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> > baseclass_0;
  std::allocator<std::pair<char const * const,int> > _Alval;
};


struct std::_Tree<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<char const *,int,iless,std::allocator<std::pair<char const * const,int> > >
{
  std::_Tree<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> > baseclass_0;
};


struct std::allocator<std::pair<char const * const,int> >::rebind<std::pair<char const * const,int> >
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,int> >::rebind<std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,int> >::rebind<std::_Tree_nod<std::_Tmap_traits<char const *,int,iless,std::allocator<std::pair<char const * const,int> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,int> >::rebind<char const *>
{
  char dummy[1];
};


struct std::allocator<std::pair<char const * const,int> >::rebind<char>
{
  char dummy[1];
};


struct CMemoryPool<CFindPath::NODE>::CPool
{
  CFindPath::NODE *m_pT;
  CIOSpinLock m_lock;
};


struct CMemoryPool<CFindPath::NODE>
{
  char dummy[1];
};


struct CDBPacket
{
  CIOObject baseclass_0;
  $043B921BF334D46A5366DAAD99B9CF56 ___u1;
};


union $043B921BF334D46A5366DAAD99B9CF56
{
  CIOBuffer *m_pBuf;
  CDBPacket *m_pNext;
};


struct CMemoryPool<CDBPacket>::CPool
{
  CDBPacket *m_pT;
  CIOSpinLock m_lock;
};


struct CMemoryPool<CDBPacket>
{
  char dummy[1];
};


struct CDBConnect
{
  void *m_hStmt;
  void *m_hDBC;
  CDBConnect *m_pNext;
};


struct CDB
{
  void *m_hStmt;
  CDBConnect *m_pDBConnect;
};


struct DATE_TIME
{
  int year;
  int month;
  int day;
  int hour;
  int minute;
  int second;
};


struct CMemoryPool<CBaseList>::CPool
{
  CBaseList *m_pT;
  CIOSpinLock m_lock;
};


struct CMemoryPool<CBaseList>
{
  char dummy[1];
};


struct CAuthPacket
{
  CIOObject baseclass_0;
  $2DC26FEE16197E798421ED09502444D2 ___u1;
};


union $2DC26FEE16197E798421ED09502444D2
{
  CIOBuffer *m_pBuf;
  CAuthPacket *m_pNext;
};


struct CMemoryPool<CAuthPacket>::CPool
{
  CAuthPacket *m_pT;
  CIOSpinLock m_lock;
};


struct CMemoryPool<CAuthPacket>
{
  char dummy[1];
};


struct std::basic_streambuf<wchar_t,std::char_traits<wchar_t> >
{
  std::basic_streambuf<wchar_t,std::char_traits<wchar_t> >Vtbl *vfptr;
  std::_Mutex _Mylock;
  wchar_t *_Gfirst;
  wchar_t *_Pfirst;
  wchar_t **_IGfirst;
  wchar_t **_IPfirst;
  wchar_t *_Gnext;
  wchar_t *_Pnext;
  wchar_t **_IGnext;
  wchar_t **_IPnext;
  int _Gcount;
  int _Pcount;
  int *_IGcount;
  int *_IPcount;
  std::locale *_Plocale;
};


struct std::basic_streambuf<wchar_t,std::char_traits<wchar_t> >Vtbl
{
  void *(__thiscall *__vecDelDtor)(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > *this, unsigned int);
  unsigned __int16 (__thiscall *overflow)(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > *this, unsigned __int16);
  unsigned __int16 (__thiscall *pbackfail)(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > *this, unsigned __int16);
  int (__thiscall *showmanyc)(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > *this);
  unsigned __int16 (__thiscall *underflow)(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > *this);
  unsigned __int16 (__thiscall *uflow)(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > *this);
  int (__thiscall *xsgetn)(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > *this, wchar_t *, int);
  int (__thiscall *xsputn)(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > *this, const wchar_t *, int);
  std::fpos<int> *(__thiscall *seekoff)(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > *this, std::fpos<int> *result, int, int, int);
  std::fpos<int> *(__thiscall *seekpos)(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > *this, std::fpos<int> *result, std::fpos<int>, int);
  std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > *(__thiscall *setbuf)(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > *this, wchar_t *, int);
  int (__thiscall *sync)(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > *this);
  void (__thiscall *imbue)(std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > *this, std::locale *);
};


struct std::char_traits<wchar_t>
{
  char dummy[1];
};


struct std::ctype<wchar_t>
{
  std::ctype_base baseclass_0;
  _Ctypevec _Ctype;
  _Cvtvec _Cvt;
};


struct std::basic_ostream<wchar_t,std::char_traits<wchar_t> >
{
  char dummy[56];
};


struct std::basic_ios<wchar_t,std::char_traits<wchar_t> >
{
  std::ios_base baseclass_0;
  std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > *_Mystrbuf;
  std::basic_ostream<wchar_t,std::char_traits<wchar_t> > *_Tiestr;
  wchar_t _Fillch;
};


struct std::basic_istream<wchar_t,std::char_traits<wchar_t> >
{
  _BYTE gap0[4];
  int _Chcount;
  _BYTE gap8[52];
};


struct std::basic_istream<wchar_t,std::char_traits<wchar_t> >::_Sentry_base
{
  std::basic_istream<wchar_t,std::char_traits<wchar_t> > *_Myistr;
};


struct std::basic_istream<wchar_t,std::char_traits<wchar_t> >::sentry
{
  std::basic_istream<wchar_t,std::char_traits<wchar_t> >::_Sentry_base baseclass_0;
  bool _Ok;
};


struct std::codecvt<wchar_t,char,int>
{
  std::codecvt_base baseclass_0;
  _Cvtvec _Cvt;
};


struct std::basic_ostream<wchar_t,std::char_traits<wchar_t> >::_Sentry_base
{
  std::basic_ostream<wchar_t,std::char_traits<wchar_t> > *_Myostr;
};


struct std::basic_ostream<wchar_t,std::char_traits<wchar_t> >::sentry
{
  std::basic_ostream<wchar_t,std::char_traits<wchar_t> >::_Sentry_base baseclass_0;
  bool _Ok;
};


struct transitiondate
{
  int yr;
  int yd;
  int ms;
};


union FT
{
  unsigned __int64 ft_scalar;
  _FILETIME ft_struct;
};


struct __lc_time_data
{
  char *wday_abbr[7];
  char *wday[7];
  char *month_abbr[12];
  char *month[12];
  char *ampm[2];
  char *ww_sdatefmt;
  char *ww_ldatefmt;
  char *ww_timefmt;
  unsigned int ww_lcid;
  int ww_caltype;
  int refcount;
};


struct threadlocaleinfostruct
{
  int refcount;
  unsigned int lc_codepage;
  unsigned int lc_collate_cp;
  unsigned int lc_handle[6];
  int lc_clike;
  int mb_cur_max;
  int *lconv_intl_refcount;
  int *lconv_num_refcount;
  int *lconv_mon_refcount;
  lconv *lconv;
  lconv *lconv_intl;
  int *ctype1_refcount;
  unsigned __int16 *ctype1;
  const unsigned __int16 *pctype;
  __lc_time_data *lc_time_curr;
  __lc_time_data *lc_time_intl;
};


struct threadmbcinfostruct
{
  int refcount;
  int mbcodepage;
  int ismbcodepage;
  int mblcid;
  unsigned __int16 mbulinfo[6];
  char mbctype[257];
  char mbcasemap[256];
};


struct _tiddata
{
  unsigned int _tid;
  unsigned int _thandle;
  int _terrno;
  unsigned int _tdoserrno;
  unsigned int _fpds;
  unsigned int _holdrand;
  char *_token;
  unsigned __int16 *_wtoken;
  char *_mtoken;
  char *_errmsg;
  unsigned __int16 *_werrmsg;
  char *_namebuf0;
  unsigned __int16 *_wnamebuf0;
  char *_namebuf1;
  unsigned __int16 *_wnamebuf1;
  char *_asctimebuf;
  unsigned __int16 *_wasctimebuf;
  void *_gmtimebuf;
  char *_cvtbuf;
  void *_initaddr;
  void *_initarg;
  void *_pxcptacttab;
  void *_tpxcptinfoptrs;
  int _tfpecode;
  threadmbcinfostruct *ptmbcinfo;
  threadlocaleinfostruct *ptlocinfo;
  unsigned int _NLG_dwCode;
  void *_terminate;
  void *_unexpected;
  void *_translator;
  void *_purecall;
  void *_curexception;
  void *_curcontext;
  int _ProcessingThrow;
  void *_pFrameInfoChain;
};


struct DOUBLE
{
  long double x;
};


union $C8014B43F160BFD769FAE3F15553333C
{
  char sz[512];
};


union $519E2A0ABDBAFFC353FD5D86715BA24D
{
  char *sz;
  unsigned __int16 *wz;
};


struct _count_string
{
  __int16 Length;
  __int16 MaximumLength;
  char *Buffer;
};


struct ioinfo
{
  int osfhnd;
  char osfile;
  char pipech;
  int lockinitflag;
  _RTL_CRITICAL_SECTION lock;
};


struct _XCPT_ACTION
{
  unsigned int XcptNum;
  int SigNum;
  void (__cdecl *XcptAction)(int);
};


struct $EC85C3A0A7878B6DC802851EB115B563
{
  _RTL_CRITICAL_SECTION *lock;
  $1DD7A03358E0D01DD359262876E6A0F0 kind;
};


struct rterrmsgs
{
  int rterrno;
  char *rterrtxt;
};


struct tagLC_ID
{
  unsigned __int16 wLanguage;
  unsigned __int16 wCountry;
  unsigned __int16 wCodePage;
};


struct tagLC_STRINGS
{
  char szLanguage[64];
  char szCountry[64];
  char szCodePage[16];
};


struct _is_ctype_compatible
{
  unsigned int id;
  int is_clike;
};


struct tagRGLOCINFO
{
  unsigned int lcid;
  char chILanguage[8];
  char *pchSEngLanguage;
  char chSAbbrevLangName[4];
  char *pchSEngCountry;
  char chSAbbrevCtryName[4];
  char chIDefaultCodepage[8];
  char chIDefaultAnsiCodepage[8];
};


struct tagLOCALETAB
{
  char *szName;
  char chAbbrev[4];
};


struct IMAGE_LOAD_CONFIG_DIRECTORY32_2
{
  unsigned int Size;
  unsigned int TimeDateStamp;
  unsigned __int16 MajorVersion;
  unsigned __int16 MinorVersion;
  unsigned int GlobalFlagsClear;
  unsigned int GlobalFlagsSet;
  unsigned int CriticalSectionDefaultTimeout;
  unsigned int DeCommitFreeBlockThreshold;
  unsigned int DeCommitTotalFreeThreshold;
  unsigned int LockPrefixTable;
  unsigned int MaximumAllocationSize;
  unsigned int VirtualMemoryThreshold;
  unsigned int ProcessHeapFlags;
  unsigned int ProcessAffinityMask;
  unsigned __int16 CSDVersion;
  unsigned __int16 Reserved1;
  unsigned int EditList;
  unsigned int *SecurityCookie;
  void **SEHandlerTable;
  unsigned int SEHandlerCount;
};


struct __declspec(align(32)) _JMP_BUF
{
  unsigned int saved_ebp;
  unsigned int saved_ebx;
  unsigned int saved_edi;
  unsigned int saved_esi;
  unsigned int saved_esp;
  unsigned int saved_return;
  unsigned int saved_xregistration;
  unsigned int saved_trylevel;
  unsigned int version_cookie;
  unsigned int unwind_func;
  unsigned int unwind_data;
};


struct _SCOPETABLE_ENTRY
{
  int EnclosingLevel;
  void *FilterFunc;
  void *HandlerFunc;
};


struct _EXCEPTION_REGISTRATION
{
  unsigned int prev;
  unsigned int handler;
};


struct _NLG_INFO
{
  unsigned int dwSig;
  unsigned int uoffDestination;
  unsigned int dwCode;
  unsigned int uoffFramePointer;
};


struct _C9_EXCEPTION_REGISTRATION
{
  unsigned int er_prev;
  unsigned int er_handler;
  unsigned int scopetable;
  unsigned int trylevel;
};


struct _EXCEPTION_REGISTRATION_COMMON
{
  _BYTE gap0[8];
  unsigned int scopetable;
  unsigned int trylevel;
};


struct _EH3_EXCEPTION_REGISTRATION
{
  _EH3_EXCEPTION_REGISTRATION *Next;
  void *ExceptionHandler;
  _SCOPETABLE_ENTRY *ScopeTable;
  unsigned int TryLevel;
};


struct code_page_info
{
  int code_page;
  unsigned __int16 mbulinfo[6];
  char rgrange[4][8];
};


struct $9EDDA679613D7E4E5E37CB563F432A3F
{
  unsigned int lowerhalf;
  int upperhalf;
};


union doubleint
{
  __int64 bigint;
  $9EDDA679613D7E4E5E37CB563F432A3F twoints;
};


struct tagEntry
{
  int sizeFront;
  tagEntry *pEntryNext;
  tagEntry *pEntryPrev;
};


struct tagListHead
{
  tagEntry *pEntryNext;
  tagEntry *pEntryPrev;
};


struct tagGroup
{
  int cntEntries;
  tagListHead listHead[64];
};


struct tagRegion
{
  int indGroupUse;
  char cntRegionSize[64];
  unsigned int bitvGroupHi[32];
  unsigned int bitvGroupLo[32];
  tagGroup grpHeadList[32];
};


struct tagHeader
{
  unsigned int bitvEntryHi;
  unsigned int bitvEntryLo;
  unsigned int bitvCommit;
  void *pHeapData;
  tagRegion *pRegion;
};


struct tagEntryEnd
{
  int sizeBack;
};


struct TypeDescriptor
{
  unsigned int hash;
  void *spare;
  char name[];
};


struct _s_CatchableType
{
  unsigned int properties;
  TypeDescriptor *pType;
  PMD thisDisplacement;
  int sizeOrOffset;
  void (__cdecl *copyFunction)();
};


struct _s_CatchableTypeArray
{
  int nCatchableTypes;
  _s_CatchableType *arrayOfCatchableTypes[];
};


struct _s_HandlerType
{
  unsigned int adjectives;
  TypeDescriptor *pType;
  int dispCatchObj;
  void *addressOfHandler;
};


struct _s_ESTypeList
{
  int nCount;
  _s_HandlerType *pTypeArray;
};


struct _s_ThrowInfo
{
  unsigned int attributes;
  void (__cdecl *pmfnUnwind)();
  int (__cdecl *pForwardCompat)();
  _s_CatchableTypeArray *pCatchableTypeArray;
};


struct _s_UnwindMapEntry
{
  int toState;
  void (__cdecl *action)();
};


struct _s_TryBlockMapEntry
{
  int tryLow;
  int tryHigh;
  int catchHigh;
  int nCatches;
  _s_HandlerType *pHandlerArray;
};


struct _s_FuncInfo
{
  int _bf0;
  int maxState;
  _s_UnwindMapEntry *pUnwindMap;
  unsigned int nTryBlocks;
  _s_TryBlockMapEntry *pTryBlockMap;
  unsigned int nIPMapEntries;
  void *pIPtoStateMap;
  _s_ESTypeList *pESTypeList;
};


struct EHExceptionRecord::EHParameters
{
  unsigned int magicNumber;
  void *pExceptionObject;
  _s_ThrowInfo *pThrowInfo;
};


struct EHExceptionRecord
{
  unsigned int ExceptionCode;
  unsigned int ExceptionFlags;
  _EXCEPTION_RECORD *ExceptionRecord;
  void *ExceptionAddress;
  unsigned int NumberParameters;
  EHExceptionRecord::EHParameters params;
};


struct EHRegistrationNode
{
  EHRegistrationNode *pNext;
  void *frameHandler;
  int state;
};


struct CatchGuardRN
{
  EHRegistrationNode *pNext;
  void *pFrameHandler;
  unsigned int RandomCookie;
  _s_FuncInfo *pFuncInfo;
  EHRegistrationNode *pRN;
  int CatchDepth;
};


struct TranslatorGuardRN
{
  EHRegistrationNode *pNext;
  void *pFrameHandler;
  unsigned int RandomCookie;
  _s_FuncInfo *pFuncInfo;
  EHRegistrationNode *pRN;
  int CatchDepth;
  EHRegistrationNode *pMarkerRN;
  void *ESP;
  void *EBP;
  int DidUnwind;
};


struct FrameInfo
{
  void *pExceptionObject;
  FrameInfo *pNext;
};


struct __JUMP_BUFFER
{
  unsigned int Ebp;
  unsigned int Ebx;
  unsigned int Edi;
  unsigned int Esi;
  unsigned int Esp;
  unsigned int Eip;
  unsigned int Registration;
  unsigned int TryLevel;
  unsigned int Cookie;
  unsigned int UnwindFunc;
  unsigned int UnwindData[6];
};


struct errentry
{
  unsigned int oscode;
  int errnocode;
};


struct std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0>
{
  std::less<int> comp;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node> baseclass_0;
};


struct std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >
{
  std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node> _Alnod;
};


struct std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node *>
{
  std::_Allocator_base<std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node *> baseclass_0;
};


struct std::_Tree_ptr<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >
{
  std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> > baseclass_0;
  std::allocator<std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node *> _Alptr;
};


struct std::_Allocator_base<std::pair<int const ,QUEST> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,QUEST> >
{
  std::_Allocator_base<std::pair<int const ,QUEST> > baseclass_0;
};


struct std::_Tree_val<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >
{
  std::_Tree_ptr<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> > baseclass_0;
  std::allocator<std::pair<int const ,QUEST> > _Alval;
};


struct std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node
{
  std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node *_Left;
  std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node *_Parent;
  std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node *_Right;
  std::pair<int const ,QUEST> _Myval;
  char _Color;
  char _Isnil;
};


struct QUEST
{
  int nStage;
  int bEnd;
};


struct std::pair<int const ,QUEST>
{
  const int first;
  QUEST second;
};


struct std::_Tree<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >
{
  std::_Tree_val<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> > baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node *_Myhead;
  unsigned int _Mysize;
};


struct std::map<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> > >
{
  std::_Tree<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> > baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,QUEST>,int,std::pair<int const ,QUEST> const *,std::pair<int const ,QUEST> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,QUEST>,int,std::pair<int const ,QUEST> const *,std::pair<int const ,QUEST> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,QUEST>,int,std::pair<int const ,QUEST> const *,std::pair<int const ,QUEST> const &> baseclass_0;
};


union $A733C6F4EA035BA9643F9DDDA1AA8DD3
{
  std::_Bidit<std::pair<int const ,QUEST>,int,std::pair<int const ,QUEST> const *,std::pair<int const ,QUEST> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::const_iterator
{
  $A733C6F4EA035BA9643F9DDDA1AA8DD3 ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::const_iterator baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::iterator first;
  bool second;
};


struct std::allocator<std::pair<int const ,QUEST> >::rebind<std::pair<int const ,QUEST> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,QUEST> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,QUEST> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,QUEST,std::less<int>,std::allocator<std::pair<int const ,QUEST> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,QUEST> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,QUEST> >::rebind<char>
{
  char dummy[1];
};


struct CMock
{
  CBlow baseclass_0;
};


struct CNegative
{
  CBlow baseclass_0;
};


struct CSacrifice
{
  CBlow baseclass_0;
};


struct CTranscendental
{
  CBlow baseclass_0;
};


struct CHealingAny
{
  CSkill baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,MYQUEST>,int,std::pair<int const ,MYQUEST> const *,std::pair<int const ,MYQUEST> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,MYQUEST>,int,std::pair<int const ,MYQUEST> const *,std::pair<int const ,MYQUEST> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,MYQUEST>,int,std::pair<int const ,MYQUEST> const *,std::pair<int const ,MYQUEST> const &> baseclass_0;
};


union $D6BB029F5409A503388C7A37600EAD16
{
  std::_Bidit<std::pair<int const ,MYQUEST>,int,std::pair<int const ,MYQUEST> const *,std::pair<int const ,MYQUEST> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::const_iterator
{
  $D6BB029F5409A503388C7A37600EAD16 ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::const_iterator baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::iterator first;
  bool second;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::iterator,std::_Tree<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::iterator>
{
  std::_Tree<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::iterator first;
  std::_Tree<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::iterator second;
};


struct std::allocator<std::pair<int const ,MYQUEST> >::rebind<std::pair<int const ,MYQUEST> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,MYQUEST> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,MYQUEST> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,MYQUEST> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,MYQUEST> >::rebind<char>
{
  char dummy[1];
};


struct CNPCQuest
{
  CNPC baseclass_0;
};


struct CCondContribute
{
  CCondition baseclass_0;
};


struct std::iterator<std::random_access_iterator_tag,QUESTITEM,int,QUESTITEM const *,QUESTITEM const &>
{
  char dummy[1];
};


struct std::_Ranit<QUESTITEM,int,QUESTITEM const *,QUESTITEM const &>
{
  std::iterator<std::random_access_iterator_tag,QUESTITEM,int,QUESTITEM const *,QUESTITEM const &> baseclass_0;
};


union $814A0CD07D478F16135BC30414168B42
{
  std::_Ranit<QUESTITEM,int,QUESTITEM const *,QUESTITEM const &> baseclass_0;
  QUESTITEM *_Myptr;
};


struct std::vector<QUESTITEM,std::allocator<QUESTITEM> >::const_iterator
{
  $814A0CD07D478F16135BC30414168B42 ___u0;
};


struct std::vector<QUESTITEM,std::allocator<QUESTITEM> >::iterator
{
  std::vector<QUESTITEM,std::allocator<QUESTITEM> >::const_iterator baseclass_0;
};


struct CActionHtml
{
  CAction baseclass_0;
};


struct CActionLink
{
  CAction baseclass_0;
};


struct CActionExp
{
  CAction baseclass_0;
};


struct CActionItem
{
  CAction baseclass_0;
  std::vector<QUESTITEM,std::allocator<QUESTITEM> > m_vecQItem;
};


struct CActionCon
{
  CAction baseclass_0;
};


struct CActionSUP
{
  CAction baseclass_0;
};


struct CActionSaveFlag
{
  CAction baseclass_0;
};


struct CActionClear
{
  CAction baseclass_0;
};


struct std::iterator<std::random_access_iterator_tag,CAction *,int,CAction * const *,CAction * const &>
{
  char dummy[1];
};


struct std::_Ranit<CAction *,int,CAction * const *,CAction * const &>
{
  std::iterator<std::random_access_iterator_tag,CAction *,int,CAction * const *,CAction * const &> baseclass_0;
};


union $40A2E9053B7DE1F6EF6BE6BE0657B4C0
{
  std::_Ranit<CAction *,int,CAction * const *,CAction * const &> baseclass_0;
  CAction **_Myptr;
};


struct std::vector<CAction *,std::allocator<CAction *> >::const_iterator
{
  $40A2E9053B7DE1F6EF6BE6BE0657B4C0 ___u0;
};


struct std::vector<CAction *,std::allocator<CAction *> >::iterator
{
  std::vector<CAction *,std::allocator<CAction *> >::const_iterator baseclass_0;
};


struct std::iterator<std::random_access_iterator_tag,CCase *,int,CCase * const *,CCase * const &>
{
  char dummy[1];
};


struct std::_Ranit<CCase *,int,CCase * const *,CCase * const &>
{
  std::iterator<std::random_access_iterator_tag,CCase *,int,CCase * const *,CCase * const &> baseclass_0;
};


union $2F46BD0C09150A5B05B997DAE99BFFA0
{
  std::_Ranit<CCase *,int,CCase * const *,CCase * const &> baseclass_0;
  CCase **_Myptr;
};


struct std::vector<CCase *,std::allocator<CCase *> >::const_iterator
{
  $2F46BD0C09150A5B05B997DAE99BFFA0 ___u0;
};


struct std::vector<CCase *,std::allocator<CCase *> >::iterator
{
  std::vector<CCase *,std::allocator<CCase *> >::const_iterator baseclass_0;
};


struct std::_Vector_val<CAction *,std::allocator<CAction *> >
{
  std::allocator<CAction *> _Alval;
};


struct std::vector<CAction *,std::allocator<CAction *> >
{
  std::_Vector_val<CAction *,std::allocator<CAction *> > baseclass_0;
  CAction **_Myfirst;
  CAction **_Mylast;
  CAction **_Myend;
};


struct std::_Vector_val<CCase *,std::allocator<CCase *> >
{
  std::allocator<CCase *> _Alval;
};


struct std::vector<CCase *,std::allocator<CCase *> >
{
  std::_Vector_val<CCase *,std::allocator<CCase *> > baseclass_0;
  CCase **_Myfirst;
  CCase **_Mylast;
  CCase **_Myend;
};


struct std::allocator<QUESTITEM>::rebind<QUESTITEM>
{
  char dummy[1];
};


struct std::allocator<CAction *>::rebind<CAction *>
{
  char dummy[1];
};


struct std::allocator<CCase *>::rebind<CCase *>
{
  char dummy[1];
};


struct std::iterator<std::bidirectional_iterator_tag,CCase *,int,CCase * const *,CCase * const &>
{
  char dummy[1];
};


struct std::_Bidit<CCase *,int,CCase * const *,CCase * const &>
{
  std::iterator<std::bidirectional_iterator_tag,CCase *,int,CCase * const *,CCase * const &> baseclass_0;
};


union $AF73B36926BD972FAB3FD1F91EEF26C2
{
  std::_Bidit<CCase *,int,CCase * const *,CCase * const &> baseclass_0;
  std::_List_nod<CCase *,std::allocator<CCase *> >::_Node *_Ptr;
};


struct std::list<CCase *,std::allocator<CCase *> >::const_iterator
{
  $AF73B36926BD972FAB3FD1F91EEF26C2 ___u0;
};


struct std::list<CCase *,std::allocator<CCase *> >::iterator
{
  std::list<CCase *,std::allocator<CCase *> >::const_iterator baseclass_0;
};


struct std::allocator<CCase *>::rebind<std::_List_nod<CCase *,std::allocator<CCase *> >::_Node>
{
  char dummy[1];
};


struct std::allocator<CCase *>::rebind<std::_List_nod<CCase *,std::allocator<CCase *> >::_Node *>
{
  char dummy[1];
};


struct CCondClear
{
  CCondition baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,CCondition *,int,CCondition * const *,CCondition * const &>
{
  char dummy[1];
};


struct std::_Bidit<CCondition *,int,CCondition * const *,CCondition * const &>
{
  std::iterator<std::bidirectional_iterator_tag,CCondition *,int,CCondition * const *,CCondition * const &> baseclass_0;
};


union $DBC7291A0EB1531E88DD1B74A12DB58E
{
  std::_Bidit<CCondition *,int,CCondition * const *,CCondition * const &> baseclass_0;
  std::_List_nod<CCondition *,std::allocator<CCondition *> >::_Node *_Ptr;
};


struct std::list<CCondition *,std::allocator<CCondition *> >::const_iterator
{
  $DBC7291A0EB1531E88DD1B74A12DB58E ___u0;
};


struct std::list<CCondition *,std::allocator<CCondition *> >::iterator
{
  std::list<CCondition *,std::allocator<CCondition *> >::const_iterator baseclass_0;
};


struct std::iterator<std::bidirectional_iterator_tag,CAction *,int,CAction * const *,CAction * const &>
{
  char dummy[1];
};


struct std::_Bidit<CAction *,int,CAction * const *,CAction * const &>
{
  std::iterator<std::bidirectional_iterator_tag,CAction *,int,CAction * const *,CAction * const &> baseclass_0;
};


union $AB1EAA8134285F5BEF415CE2328B6854
{
  std::_Bidit<CAction *,int,CAction * const *,CAction * const &> baseclass_0;
  std::_List_nod<CAction *,std::allocator<CAction *> >::_Node *_Ptr;
};


struct std::list<CAction *,std::allocator<CAction *> >::const_iterator
{
  $AB1EAA8134285F5BEF415CE2328B6854 ___u0;
};


struct std::list<CAction *,std::allocator<CAction *> >::iterator
{
  std::list<CAction *,std::allocator<CAction *> >::const_iterator baseclass_0;
};


struct std::allocator<CCondition *>::rebind<std::_List_nod<CCondition *,std::allocator<CCondition *> >::_Node>
{
  char dummy[1];
};


struct std::allocator<CCondition *>::rebind<std::_List_nod<CCondition *,std::allocator<CCondition *> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<CAction *>::rebind<std::_List_nod<CAction *,std::allocator<CAction *> >::_Node>
{
  char dummy[1];
};


struct std::allocator<CAction *>::rebind<std::_List_nod<CAction *,std::allocator<CAction *> >::_Node *>
{
  char dummy[1];
};


struct std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,STORAGEITEM>,int,std::pair<int const ,STORAGEITEM> const *,std::pair<int const ,STORAGEITEM> const &>
{
  char dummy[1];
};


struct std::_Bidit<std::pair<int const ,STORAGEITEM>,int,std::pair<int const ,STORAGEITEM> const *,std::pair<int const ,STORAGEITEM> const &>
{
  std::iterator<std::bidirectional_iterator_tag,std::pair<int const ,STORAGEITEM>,int,std::pair<int const ,STORAGEITEM> const *,std::pair<int const ,STORAGEITEM> const &> baseclass_0;
};


union $5FA2994DF9A94184B48582895B4985A6
{
  std::_Bidit<std::pair<int const ,STORAGEITEM>,int,std::pair<int const ,STORAGEITEM> const *,std::pair<int const ,STORAGEITEM> const &> baseclass_0;
  std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node *_Ptr;
};


struct std::_Tree<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::const_iterator
{
  $5FA2994DF9A94184B48582895B4985A6 ___u0;
};


struct std::_Tree<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::iterator
{
  std::_Tree<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::const_iterator baseclass_0;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::iterator,bool>
{
  std::_Tree<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::iterator first;
  bool second;
};


struct std::pair<std::_Tree<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::iterator,std::_Tree<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::ite
{
  std::_Tree<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::iterator first;
  std::_Tree<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::iterator second;
};


struct std::allocator<std::pair<int const ,STORAGEITEM> >::rebind<std::pair<int const ,STORAGEITEM> >
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,STORAGEITEM> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,STORAGEITEM> >::rebind<std::_Tree_nod<std::_Tmap_traits<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> >,0> >::_Node *>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,STORAGEITEM> >::rebind<int>
{
  char dummy[1];
};


struct std::allocator<std::pair<int const ,STORAGEITEM> >::rebind<char>
{
  char dummy[1];
};


struct CActionSpecialty
{
  CAction baseclass_0;
};


struct CShock
{
  CMagic baseclass_0;
};


struct std::allocator<QUESTITEMDROP>::rebind<QUESTITEMDROP>
{
  char dummy[1];
};


struct _msExcept7
{
  int Magic;
  int Count;
  void *InfoPtr;
  int CountDtr;
  void *DtrPtr;
  int _unk[2];
};


struct _msExcInfo
{
  int Id;
  void *Proc;
};

You must be registered to see links

Example usefull content from the List:

Code:

struct CChar
{
  CBase baseclass_0;
  char m_szName[25];
  int m_nLevel;
  PROPERTY_BASE m_prtyBase;
  PROPERTY_PT m_prtyPt;
  PROPERTY_PER m_prtyPer;
  int m_nCurHP;
  int m_nCurMP;
  int m_nGState;
  int m_nMState;
  int m_nRange;
  int m_nMap;
  CSMap *m_pMap;
  tagPOINT m_ptTile;
  tagPOINT m_ptPixel;
  int m_nZ;
  int m_nQIndex;
  int m_nDir;
  CIOCriticalSection m_lock;
  CLink m_link;
};


struct CPlayer
{
  CChar baseclass_0;
  int m_nUID;
  int m_nPID;
  int m_nAdmin;
  int m_nClass;
  unsigned int m_dwSpecialty;
  int m_nContribute;
  __int64 m_nExp;
  int m_nGID;
  int m_nGRole;
  int m_nMoney;
  int m_nPUPoint;
  int m_nSUPoint;
  int m_nKilled;
  int m_nFace;
  int m_nHair;
  unsigned int m_dwWearState;
  unsigned int m_dwEState;
  CPlayerSkill m_skill;
  int m_nParty;
  CIOCriticalSection m_lockItem;
  unsigned __int16 m_wWearItem[7];
  std::map<int,CItem *,std::less<int>,std::allocator<std::pair<int const ,CItem *> > > m_mapItem;
  std::vector<TRADEITEM,std::allocator<TRADEITEM> > m_vecTrade;
  CItemMoney *m_pMoney;
  CTrade *m_pTrade;
  std::map<int,STORAGEITEM,std::less<int>,std::allocator<std::pair<int const ,STORAGEITEM> > > m_mapStorage;
  int m_nCache;
  CIOCriticalSection m_lockQuest;
  std::map<int,MYQUEST,std::less<int>,std::allocator<std::pair<int const ,MYQUEST> > > m_mapMyQuest;
  unsigned int m_dwAutoSave;
  unsigned int m_dwNextAutoRefresh;
  unsigned int m_dwNextAction;
  unsigned int m_dwNextRefresh;
  int m_nTeleMap;
  tagPOINT m_ptTelePixel;
  int m_nTeleZ;
  CSocket *m_pSocket;
};

struct CPlayerSkill
{
  CPlayer *m_pOwner;
  int m_nClass;
  unsigned int m_dwSkill;
  CSkill *m_pSkill[32];
};

Special thanks to striker, he brought me to the Idea, to dump the Mainserver.pdb file : )

Akamaru · Aug 24, 2013

Let's start with pretty lame question.
Is there any trick to localize any value from this list or it's just an info that it exists

?

I want to find player's trade vector, where should I start?

MadKnight · Aug 25, 2013

"Is there any trick to localize any value from this list or it's just an info that it exists

?"
The values are in correct order (or should be in correct order ^^)
So if you want to find a Value from this Structs begin with an Offset you know and count 4 Bytes step forwards.
Example:

struct CPlayer
{
CChar baseclass_0;
int m_nUID; // -> __asm mov eax, [playerp+448] (112 as int pointer offset)
int m_nPID; // -> __asm mov eax, [playerp+452] (113 as int pointer offset)
int m_nAdmin; // -> __asm mov eax, [playerp+456] (114 as int pointer offset)
int m_nClass; // now you will know what this will be ^^

Some things are Pointers instead of an Value like:

int m_nTeleZ;
CSocket *m_pSocket; // << Pointer, to access things like this you first step
//to the Pointer and then step from this Pointer into its offset
// Example for getting IP out of the Socket Pointer ->
//return inet_ntoa(((struct in_addr*)((int*) this->thispointer)[419])[35]); //419*4 = 1676
};

strik3r2k5 · Aug 25, 2013

Akamaru said:
Let's start with pretty lame question.
Is there any trick to localize any value from this list or it's just an info that it exists?

I want to find player's trade vector, where should I start?

When I'm back from Tunesia I can give you the Trade-vector offset... just send me a pm in a week xD
OR if I remember it right, I gave it once to Mad..Mad, check our msn/skype log xD

KingForex · Aug 26, 2013

Hello MadKnight, I got some problems here
1st when i try to

Then go to Project Settings (Right Click on your Project) and goto VC++ Directories and add to Include Directories: C:\Program Files (x86)\Microsoft Research\Detours Express 3.0\include
And to Library Directories : C:\Program Files (x86)\Microsoft Research\Detours Express 3.0\lib.X86

apper redline under those

#include <cstdio>
#include <windows.h>
#include <detours.h>
#include <process.h>

how could i make them all work together! as i remember i did it once before and it's work, but i forgot the steps now.

i tryed to do it for 4days but i faild i used my brain and i faild too

, so i decided to ask for some help

Welcome!

[Tutorial] How to Detour the Kal Mainserver

Supreme Arcanarch

Newbie Spellweaver

Supreme Arcanarch

Newbie Spellweaver

Supreme Arcanarch

Newbie Spellweaver

Modeler / C++ Coder

Supreme Arcanarch

Newbie Spellweaver

Junior Spellweaver

:O

Junior Spellweaver

Newbie Spellweaver

Supreme Arcanarch

:O

Elite Diviner

Junior Spellweaver

Elite Diviner

:O

Junior Spellweaver

About Us

Online statistics

Forum statistics

RaGEZONE Sponsor