/*
** Lua binding: item
** Generated automatically by tolua++-1.0.92 on 02/19/08 02:16:25.
*/

#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"

#include "tolua++.h"

/* Exported function */
TOLUA_API int  tolua_item_open (lua_State* tolua_S);


/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_StatBase (lua_State* tolua_S)
{
 StatBase* self = (StatBase*) tolua_tousertype(tolua_S,1,0);
	delete self;
	return 0;
}

static int tolua_collect_Item (lua_State* tolua_S)
{
 Item* self = (Item*) tolua_tousertype(tolua_S,1,0);
	delete self;
	return 0;
}

static int tolua_collect_std__vector_MagicPrefixType__MagicPrefixType_ (lua_State* tolua_S)
{
 std::vector<MagicPrefixType::MagicPrefixType>* self = (std::vector<MagicPrefixType::MagicPrefixType>*) tolua_tousertype(tolua_S,1,0);
	delete self;
	return 0;
}

static int tolua_collect_std__vector_StatBase_ (lua_State* tolua_S)
{
 std::vector<StatBase>* self = (std::vector<StatBase>*) tolua_tousertype(tolua_S,1,0);
	delete self;
	return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"BaseSetItem");
 tolua_usertype(tolua_S,"DamageType::DamageType");
 tolua_usertype(tolua_S,"BaseStat");
 tolua_usertype(tolua_S,"Item");
 tolua_usertype(tolua_S,"SkillType::SkillType");
 tolua_usertype(tolua_S,"CharacterClass::CharacterClass");
 tolua_usertype(tolua_S,"ItemType::ItemType");
 tolua_usertype(tolua_S,"BaseItem");
 tolua_usertype(tolua_S,"SkillTab::SkillTab");
 tolua_usertype(tolua_S,"std::vector<MagicPrefixType::MagicPrefixType>");
 tolua_usertype(tolua_S,"std::vector<StatBase>");
 tolua_usertype(tolua_S,"std::vector<MagicSuffixType::MagicSuffixType>");
 tolua_usertype(tolua_S,"ItemAffix");
 tolua_usertype(tolua_S,"ItemNames");
 tolua_usertype(tolua_S,"BaseRuneword");
 tolua_usertype(tolua_S,"BaseUniqueItem");
 tolua_usertype(tolua_S,"NPCCode::NPCCode");
 tolua_usertype(tolua_S,"ItemKind::ItemKind");
 tolua_usertype(tolua_S,"SetItemType::SetItemType");
 tolua_usertype(tolua_S,"StatBase");
 tolua_usertype(tolua_S,"ItemSet");
 tolua_usertype(tolua_S,"BaseProperty");
 tolua_usertype(tolua_S,"BaseItemType");
}

/* get function: Index of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Index
static int tolua_get_BaseItemType_Index(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Index);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Index of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Index
static int tolua_set_BaseItemType_Index(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Index = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Type of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Type
static int tolua_get_BaseItemType_Type(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->Type,"ItemKind::ItemKind");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Type of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Type
static int tolua_set_BaseItemType_Type(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",NULL);
  if (!tolua_isusertype(tolua_S,2,"ItemKind::ItemKind",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Type = *((ItemKind::ItemKind*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Name of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Name
static int tolua_get_BaseItemType_Name(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Name);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Name of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Name
static int tolua_set_BaseItemType_Name(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Name = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Code of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Code
static int tolua_get_BaseItemType_Code(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Code'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Code);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Code of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Code
static int tolua_set_BaseItemType_Code(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Code'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Code = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Equiv1 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Equiv1
static int tolua_get_BaseItemType_Equiv1(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Equiv1'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Equiv1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Equiv1 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Equiv1
static int tolua_set_BaseItemType_Equiv1(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Equiv1'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Equiv1 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Equiv2 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Equiv2
static int tolua_get_BaseItemType_Equiv2(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Equiv2'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Equiv2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Equiv2 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Equiv2
static int tolua_set_BaseItemType_Equiv2(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Equiv2'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Equiv2 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Repair of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Repair
static int tolua_get_BaseItemType_Repair(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Repair'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->Repair);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Repair of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Repair
static int tolua_set_BaseItemType_Repair(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Repair'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Repair = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Body of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Body
static int tolua_get_BaseItemType_Body(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Body'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->Body);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Body of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Body
static int tolua_set_BaseItemType_Body(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Body'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Body = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: BodyLoc1 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_BodyLoc1
static int tolua_get_BaseItemType_BodyLoc1(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'BodyLoc1'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->BodyLoc1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: BodyLoc1 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_BodyLoc1
static int tolua_set_BaseItemType_BodyLoc1(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'BodyLoc1'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->BodyLoc1 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: BodyLoc2 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_BodyLoc2
static int tolua_get_BaseItemType_BodyLoc2(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'BodyLoc2'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->BodyLoc2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: BodyLoc2 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_BodyLoc2
static int tolua_set_BaseItemType_BodyLoc2(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'BodyLoc2'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->BodyLoc2 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Shoots of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Shoots
static int tolua_get_BaseItemType_Shoots(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Shoots'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Shoots);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Shoots of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Shoots
static int tolua_set_BaseItemType_Shoots(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Shoots'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Shoots = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Quiver of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Quiver
static int tolua_get_BaseItemType_Quiver(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Quiver'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Quiver);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Quiver of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Quiver
static int tolua_set_BaseItemType_Quiver(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Quiver'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Quiver = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Throwable of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Throwable
static int tolua_get_BaseItemType_Throwable(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Throwable'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->Throwable);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Throwable of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Throwable
static int tolua_set_BaseItemType_Throwable(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Throwable'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Throwable = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Reload of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Reload
static int tolua_get_BaseItemType_Reload(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Reload'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->Reload);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Reload of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Reload
static int tolua_set_BaseItemType_Reload(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Reload'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Reload = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ReEquip of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_ReEquip
static int tolua_get_BaseItemType_ReEquip(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ReEquip'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->ReEquip);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ReEquip of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_ReEquip
static int tolua_set_BaseItemType_ReEquip(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ReEquip'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ReEquip = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AutoStack of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_AutoStack
static int tolua_get_BaseItemType_AutoStack(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AutoStack'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->AutoStack);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AutoStack of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_AutoStack
static int tolua_set_BaseItemType_AutoStack(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AutoStack'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AutoStack = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Magic of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Magic
static int tolua_get_BaseItemType_Magic(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Magic'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->Magic);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Magic of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Magic
static int tolua_set_BaseItemType_Magic(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Magic'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Magic = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Rare of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Rare
static int tolua_get_BaseItemType_Rare(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rare'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->Rare);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Rare of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Rare
static int tolua_set_BaseItemType_Rare(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rare'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Rare = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Normal of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Normal
static int tolua_get_BaseItemType_Normal(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Normal'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->Normal);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Normal of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Normal
static int tolua_set_BaseItemType_Normal(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Normal'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Normal = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Charm of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Charm
static int tolua_get_BaseItemType_Charm(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Charm'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->Charm);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Charm of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Charm
static int tolua_set_BaseItemType_Charm(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Charm'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Charm = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Gem of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Gem
static int tolua_get_BaseItemType_Gem(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Gem'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->Gem);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Gem of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Gem
static int tolua_set_BaseItemType_Gem(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Gem'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Gem = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Beltable of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Beltable
static int tolua_get_BaseItemType_Beltable(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Beltable'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->Beltable);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Beltable of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Beltable
static int tolua_set_BaseItemType_Beltable(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Beltable'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Beltable = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: MaxSock1 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_MaxSock1
static int tolua_get_BaseItemType_MaxSock1(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxSock1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->MaxSock1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: MaxSock1 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_MaxSock1
static int tolua_set_BaseItemType_MaxSock1(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxSock1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->MaxSock1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: MaxSock25 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_MaxSock25
static int tolua_get_BaseItemType_MaxSock25(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxSock25'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->MaxSock25);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: MaxSock25 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_MaxSock25
static int tolua_set_BaseItemType_MaxSock25(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxSock25'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->MaxSock25 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: MaxSock40 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_MaxSock40
static int tolua_get_BaseItemType_MaxSock40(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxSock40'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->MaxSock40);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: MaxSock40 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_MaxSock40
static int tolua_set_BaseItemType_MaxSock40(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxSock40'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->MaxSock40 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: TreasureClass of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_TreasureClass
static int tolua_get_BaseItemType_TreasureClass(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TreasureClass'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->TreasureClass);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: TreasureClass of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_TreasureClass
static int tolua_set_BaseItemType_TreasureClass(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TreasureClass'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->TreasureClass = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Rarity of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Rarity
static int tolua_get_BaseItemType_Rarity(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rarity'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Rarity);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Rarity of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Rarity
static int tolua_set_BaseItemType_Rarity(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rarity'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Rarity = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: StaffMods of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_StaffMods
static int tolua_get_BaseItemType_StaffMods(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'StaffMods'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->StaffMods,"CharacterClass::CharacterClass");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: StaffMods of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_StaffMods
static int tolua_set_BaseItemType_StaffMods(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'StaffMods'",NULL);
  if (!tolua_isusertype(tolua_S,2,"CharacterClass::CharacterClass",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->StaffMods = *((CharacterClass::CharacterClass*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: CostFormula of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_CostFormula
static int tolua_get_BaseItemType_CostFormula(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CostFormula'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->CostFormula);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: CostFormula of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_CostFormula
static int tolua_set_BaseItemType_CostFormula(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CostFormula'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->CostFormula = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Class of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Class
static int tolua_get_BaseItemType_Class(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Class'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->Class,"CharacterClass::CharacterClass");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Class of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Class
static int tolua_set_BaseItemType_Class(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Class'",NULL);
  if (!tolua_isusertype(tolua_S,2,"CharacterClass::CharacterClass",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Class = *((CharacterClass::CharacterClass*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: VarInvGfx of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_VarInvGfx
static int tolua_get_BaseItemType_VarInvGfx(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'VarInvGfx'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->VarInvGfx);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: VarInvGfx of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_VarInvGfx
static int tolua_set_BaseItemType_VarInvGfx(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'VarInvGfx'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->VarInvGfx = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: InvGfx1 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_InvGfx1
static int tolua_get_BaseItemType_InvGfx1(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvGfx1'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->InvGfx1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: InvGfx1 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_InvGfx1
static int tolua_set_BaseItemType_InvGfx1(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvGfx1'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->InvGfx1 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: InvGfx2 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_InvGfx2
static int tolua_get_BaseItemType_InvGfx2(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvGfx2'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->InvGfx2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: InvGfx2 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_InvGfx2
static int tolua_set_BaseItemType_InvGfx2(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvGfx2'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->InvGfx2 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: InvGfx3 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_InvGfx3
static int tolua_get_BaseItemType_InvGfx3(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvGfx3'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->InvGfx3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: InvGfx3 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_InvGfx3
static int tolua_set_BaseItemType_InvGfx3(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvGfx3'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->InvGfx3 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: InvGfx4 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_InvGfx4
static int tolua_get_BaseItemType_InvGfx4(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvGfx4'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->InvGfx4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: InvGfx4 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_InvGfx4
static int tolua_set_BaseItemType_InvGfx4(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvGfx4'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->InvGfx4 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: InvGfx5 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_InvGfx5
static int tolua_get_BaseItemType_InvGfx5(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvGfx5'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->InvGfx5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: InvGfx5 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_InvGfx5
static int tolua_set_BaseItemType_InvGfx5(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvGfx5'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->InvGfx5 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: InvGfx6 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_InvGfx6
static int tolua_get_BaseItemType_InvGfx6(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvGfx6'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->InvGfx6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: InvGfx6 of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_InvGfx6
static int tolua_set_BaseItemType_InvGfx6(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvGfx6'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->InvGfx6 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Page of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_get_BaseItemType_Page
static int tolua_get_BaseItemType_Page(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Page'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Page);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Page of class  BaseItemType */
#ifndef TOLUA_DISABLE_tolua_set_BaseItemType_Page
static int tolua_set_BaseItemType_Page(lua_State* tolua_S)
{
  BaseItemType* self = (BaseItemType*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Page'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Page = ((StorePage::StorePage) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: type of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_type
static int tolua_get_BaseItem_type(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'type'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->type,"ItemType::ItemType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: type of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_type
static int tolua_set_BaseItem_type(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'type'",NULL);
  if (!tolua_isusertype(tolua_S,2,"ItemType::ItemType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->type = *((ItemType::ItemType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: index of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_index
static int tolua_get_BaseItem_index(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'index'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->index);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: index of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_index
static int tolua_set_BaseItem_index(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'index'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->index = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: tableIndex of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_tableIndex
static int tolua_get_BaseItem_tableIndex(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tableIndex'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->tableIndex);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: tableIndex of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_tableIndex
static int tolua_set_BaseItem_tableIndex(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tableIndex'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->tableIndex = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: baseType of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_baseType_ptr
static int tolua_get_BaseItem_baseType_ptr(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'baseType'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->baseType,"BaseItemType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: baseType of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_baseType_ptr
static int tolua_set_BaseItem_baseType_ptr(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'baseType'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseItemType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->baseType = ((BaseItemType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: baseType2 of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_baseType2_ptr
static int tolua_get_BaseItem_baseType2_ptr(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'baseType2'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->baseType2,"BaseItemType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: baseType2 of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_baseType2_ptr
static int tolua_set_BaseItem_baseType2_ptr(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'baseType2'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseItemType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->baseType2 = ((BaseItemType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: code of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_code
static int tolua_get_BaseItem_code(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'code'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->code);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: code of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_code
static int tolua_set_BaseItem_code(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'code'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->code = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: id of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_unsigned_id
static int tolua_get_BaseItem_unsigned_id(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'id'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->id);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: id of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_unsigned_id
static int tolua_set_BaseItem_unsigned_id(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'id'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->id = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: nightmareUpgrade of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_unsigned_nightmareUpgrade
static int tolua_get_BaseItem_unsigned_nightmareUpgrade(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'nightmareUpgrade'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->nightmareUpgrade);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: nightmareUpgrade of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_unsigned_nightmareUpgrade
static int tolua_set_BaseItem_unsigned_nightmareUpgrade(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'nightmareUpgrade'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->nightmareUpgrade = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: hellUpgrade of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_unsigned_hellUpgrade
static int tolua_get_BaseItem_unsigned_hellUpgrade(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'hellUpgrade'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->hellUpgrade);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: hellUpgrade of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_unsigned_hellUpgrade
static int tolua_set_BaseItem_unsigned_hellUpgrade(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'hellUpgrade'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->hellUpgrade = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: akaraMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_akaraMagicLvl
static int tolua_get_BaseItem_akaraMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'akaraMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->akaraMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: akaraMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_akaraMagicLvl
static int tolua_set_BaseItem_akaraMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'akaraMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->akaraMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: akaraMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_akaraMagicMax
static int tolua_get_BaseItem_akaraMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'akaraMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->akaraMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: akaraMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_akaraMagicMax
static int tolua_set_BaseItem_akaraMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'akaraMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->akaraMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: akaraMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_akaraMagicMin
static int tolua_get_BaseItem_akaraMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'akaraMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->akaraMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: akaraMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_akaraMagicMin
static int tolua_set_BaseItem_akaraMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'akaraMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->akaraMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: akaraMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_akaraMax
static int tolua_get_BaseItem_akaraMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'akaraMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->akaraMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: akaraMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_akaraMax
static int tolua_set_BaseItem_akaraMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'akaraMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->akaraMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: akaraMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_akaraMin
static int tolua_get_BaseItem_akaraMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'akaraMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->akaraMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: akaraMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_akaraMin
static int tolua_set_BaseItem_akaraMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'akaraMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->akaraMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: alkorMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_alkorMagicLvl
static int tolua_get_BaseItem_alkorMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'alkorMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->alkorMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: alkorMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_alkorMagicLvl
static int tolua_set_BaseItem_alkorMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'alkorMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->alkorMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: alkorMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_alkorMagicMax
static int tolua_get_BaseItem_alkorMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'alkorMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->alkorMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: alkorMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_alkorMagicMax
static int tolua_set_BaseItem_alkorMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'alkorMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->alkorMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: alkorMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_alkorMagicMin
static int tolua_get_BaseItem_alkorMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'alkorMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->alkorMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: alkorMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_alkorMagicMin
static int tolua_set_BaseItem_alkorMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'alkorMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->alkorMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: alkorMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_alkorMax
static int tolua_get_BaseItem_alkorMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'alkorMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->alkorMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: alkorMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_alkorMax
static int tolua_set_BaseItem_alkorMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'alkorMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->alkorMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: alkorMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_alkorMin
static int tolua_get_BaseItem_alkorMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'alkorMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->alkorMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: alkorMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_alkorMin
static int tolua_set_BaseItem_alkorMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'alkorMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->alkorMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: alternateGfx of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_alternateGfx
static int tolua_get_BaseItem_alternateGfx(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'alternateGfx'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->alternateGfx);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: alternateGfx of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_alternateGfx
static int tolua_set_BaseItem_alternateGfx(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'alternateGfx'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->alternateGfx = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ashearaMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_ashearaMagicLvl
static int tolua_get_BaseItem_ashearaMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ashearaMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->ashearaMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ashearaMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_ashearaMagicLvl
static int tolua_set_BaseItem_ashearaMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ashearaMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ashearaMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ashearaMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_ashearaMagicMax
static int tolua_get_BaseItem_ashearaMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ashearaMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->ashearaMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ashearaMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_ashearaMagicMax
static int tolua_set_BaseItem_ashearaMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ashearaMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ashearaMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ashearaMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_ashearaMagicMin
static int tolua_get_BaseItem_ashearaMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ashearaMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->ashearaMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ashearaMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_ashearaMagicMin
static int tolua_set_BaseItem_ashearaMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ashearaMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ashearaMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ashearaMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_ashearaMax
static int tolua_get_BaseItem_ashearaMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ashearaMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->ashearaMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ashearaMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_ashearaMax
static int tolua_set_BaseItem_ashearaMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ashearaMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ashearaMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ashearaMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_ashearaMin
static int tolua_get_BaseItem_ashearaMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ashearaMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->ashearaMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ashearaMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_ashearaMin
static int tolua_set_BaseItem_ashearaMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ashearaMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ashearaMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: autoPrefix of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_autoPrefix
static int tolua_get_BaseItem_autoPrefix(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'autoPrefix'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->autoPrefix);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: autoPrefix of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_autoPrefix
static int tolua_set_BaseItem_autoPrefix(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'autoPrefix'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->autoPrefix = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: belt of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_belt
static int tolua_get_BaseItem_belt(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'belt'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->belt);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: belt of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_belt
static int tolua_set_BaseItem_belt(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'belt'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->belt = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: bitField1 of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_bitField1
static int tolua_get_BaseItem_bitField1(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bitField1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->bitField1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: bitField1 of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_bitField1
static int tolua_set_BaseItem_bitField1(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bitField1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->bitField1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: cainMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_cainMagicLvl
static int tolua_get_BaseItem_cainMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cainMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->cainMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: cainMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_cainMagicLvl
static int tolua_set_BaseItem_cainMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cainMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->cainMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: cainMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_cainMagicMax
static int tolua_get_BaseItem_cainMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cainMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->cainMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: cainMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_cainMagicMax
static int tolua_set_BaseItem_cainMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cainMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->cainMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: cainMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_cainMagicMin
static int tolua_get_BaseItem_cainMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cainMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->cainMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: cainMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_cainMagicMin
static int tolua_set_BaseItem_cainMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cainMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->cainMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: cainMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_cainMax
static int tolua_get_BaseItem_cainMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cainMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->cainMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: cainMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_cainMax
static int tolua_set_BaseItem_cainMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cainMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->cainMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: cainMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_cainMin
static int tolua_get_BaseItem_cainMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cainMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->cainMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: cainMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_cainMin
static int tolua_set_BaseItem_cainMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cainMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->cainMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: charsiMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_charsiMagicLvl
static int tolua_get_BaseItem_charsiMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'charsiMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->charsiMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: charsiMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_charsiMagicLvl
static int tolua_set_BaseItem_charsiMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'charsiMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->charsiMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: charsiMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_charsiMagicMax
static int tolua_get_BaseItem_charsiMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'charsiMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->charsiMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: charsiMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_charsiMagicMax
static int tolua_set_BaseItem_charsiMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'charsiMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->charsiMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: charsiMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_charsiMagicMin
static int tolua_get_BaseItem_charsiMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'charsiMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->charsiMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: charsiMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_charsiMagicMin
static int tolua_set_BaseItem_charsiMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'charsiMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->charsiMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: charsiMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_charsiMax
static int tolua_get_BaseItem_charsiMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'charsiMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->charsiMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: charsiMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_charsiMax
static int tolua_set_BaseItem_charsiMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'charsiMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->charsiMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: charsiMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_charsiMin
static int tolua_get_BaseItem_charsiMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'charsiMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->charsiMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: charsiMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_charsiMin
static int tolua_set_BaseItem_charsiMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'charsiMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->charsiMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: compactSave of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_compactSave
static int tolua_get_BaseItem_compactSave(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'compactSave'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->compactSave);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: compactSave of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_compactSave
static int tolua_set_BaseItem_compactSave(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'compactSave'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->compactSave = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: component of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_component
static int tolua_get_BaseItem_component(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'component'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->component);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: component of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_component
static int tolua_set_BaseItem_component(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'component'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->component = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: cost of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_cost
static int tolua_get_BaseItem_cost(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cost'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->cost);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: cost of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_cost
static int tolua_set_BaseItem_cost(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'cost'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->cost = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: drehyaMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_drehyaMagicLvl
static int tolua_get_BaseItem_drehyaMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drehyaMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->drehyaMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: drehyaMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_drehyaMagicLvl
static int tolua_set_BaseItem_drehyaMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drehyaMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->drehyaMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: drehyaMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_drehyaMagicMax
static int tolua_get_BaseItem_drehyaMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drehyaMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->drehyaMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: drehyaMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_drehyaMagicMax
static int tolua_set_BaseItem_drehyaMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drehyaMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->drehyaMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: drehyaMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_drehyaMagicMin
static int tolua_get_BaseItem_drehyaMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drehyaMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->drehyaMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: drehyaMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_drehyaMagicMin
static int tolua_set_BaseItem_drehyaMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drehyaMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->drehyaMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: drehyaMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_drehyaMax
static int tolua_get_BaseItem_drehyaMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drehyaMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->drehyaMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: drehyaMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_drehyaMax
static int tolua_set_BaseItem_drehyaMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drehyaMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->drehyaMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: drehyaMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_drehyaMin
static int tolua_get_BaseItem_drehyaMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drehyaMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->drehyaMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: drehyaMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_drehyaMin
static int tolua_set_BaseItem_drehyaMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drehyaMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->drehyaMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: drognanMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_drognanMagicLvl
static int tolua_get_BaseItem_drognanMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drognanMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->drognanMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: drognanMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_drognanMagicLvl
static int tolua_set_BaseItem_drognanMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drognanMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->drognanMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: drognanMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_drognanMagicMax
static int tolua_get_BaseItem_drognanMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drognanMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->drognanMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: drognanMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_drognanMagicMax
static int tolua_set_BaseItem_drognanMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drognanMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->drognanMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: drognanMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_drognanMagicMin
static int tolua_get_BaseItem_drognanMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drognanMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->drognanMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: drognanMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_drognanMagicMin
static int tolua_set_BaseItem_drognanMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drognanMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->drognanMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: drognanMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_drognanMax
static int tolua_get_BaseItem_drognanMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drognanMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->drognanMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: drognanMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_drognanMax
static int tolua_set_BaseItem_drognanMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drognanMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->drognanMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: drognanMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_drognanMin
static int tolua_get_BaseItem_drognanMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drognanMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->drognanMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: drognanMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_drognanMin
static int tolua_set_BaseItem_drognanMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'drognanMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->drognanMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: dropSfxFrame of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_dropSfxFrame
static int tolua_get_BaseItem_dropSfxFrame(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'dropSfxFrame'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->dropSfxFrame);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: dropSfxFrame of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_dropSfxFrame
static int tolua_set_BaseItem_dropSfxFrame(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'dropSfxFrame'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->dropSfxFrame = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: dropSound of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_dropSound
static int tolua_get_BaseItem_dropSound(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'dropSound'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->dropSound);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: dropSound of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_dropSound
static int tolua_set_BaseItem_dropSound(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'dropSound'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->dropSound = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: durabilityWarning of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_durabilityWarning
static int tolua_get_BaseItem_durabilityWarning(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'durabilityWarning'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->durabilityWarning);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: durabilityWarning of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_durabilityWarning
static int tolua_set_BaseItem_durabilityWarning(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'durabilityWarning'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->durabilityWarning = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: elzixMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_elzixMagicLvl
static int tolua_get_BaseItem_elzixMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'elzixMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->elzixMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: elzixMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_elzixMagicLvl
static int tolua_set_BaseItem_elzixMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'elzixMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->elzixMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: elzixMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_elzixMagicMax
static int tolua_get_BaseItem_elzixMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'elzixMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->elzixMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: elzixMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_elzixMagicMax
static int tolua_set_BaseItem_elzixMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'elzixMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->elzixMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: elzixMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_elzixMagicMin
static int tolua_get_BaseItem_elzixMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'elzixMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->elzixMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: elzixMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_elzixMagicMin
static int tolua_set_BaseItem_elzixMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'elzixMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->elzixMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: elzixMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_elzixMax
static int tolua_get_BaseItem_elzixMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'elzixMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->elzixMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: elzixMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_elzixMax
static int tolua_set_BaseItem_elzixMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'elzixMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->elzixMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: elzixMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_elzixMin
static int tolua_get_BaseItem_elzixMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'elzixMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->elzixMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: elzixMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_elzixMin
static int tolua_set_BaseItem_elzixMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'elzixMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->elzixMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: faraMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_faraMagicLvl
static int tolua_get_BaseItem_faraMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'faraMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->faraMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: faraMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_faraMagicLvl
static int tolua_set_BaseItem_faraMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'faraMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->faraMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: faraMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_faraMagicMax
static int tolua_get_BaseItem_faraMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'faraMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->faraMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: faraMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_faraMagicMax
static int tolua_set_BaseItem_faraMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'faraMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->faraMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: faraMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_faraMagicMin
static int tolua_get_BaseItem_faraMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'faraMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->faraMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: faraMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_faraMagicMin
static int tolua_set_BaseItem_faraMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'faraMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->faraMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: faraMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_faraMax
static int tolua_get_BaseItem_faraMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'faraMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->faraMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: faraMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_faraMax
static int tolua_set_BaseItem_faraMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'faraMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->faraMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: faraMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_faraMin
static int tolua_get_BaseItem_faraMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'faraMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->faraMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: faraMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_faraMin
static int tolua_set_BaseItem_faraMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'faraMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->faraMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: flippyFile of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_flippyFile
static int tolua_get_BaseItem_flippyFile(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'flippyFile'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->flippyFile);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: flippyFile of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_flippyFile
static int tolua_set_BaseItem_flippyFile(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'flippyFile'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->flippyFile = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: gambleCost of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_gambleCost
static int tolua_get_BaseItem_gambleCost(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gambleCost'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->gambleCost);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: gambleCost of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_gambleCost
static int tolua_set_BaseItem_gambleCost(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gambleCost'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->gambleCost = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: gameArt of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_gameArt
static int tolua_get_BaseItem_gameArt(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gameArt'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->gameArt);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: gameArt of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_gameArt
static int tolua_set_BaseItem_gameArt(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gameArt'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->gameArt = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: gemApplyType of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_gemApplyType
static int tolua_get_BaseItem_gemApplyType(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gemApplyType'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->gemApplyType);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: gemApplyType of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_gemApplyType
static int tolua_set_BaseItem_gemApplyType(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gemApplyType'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->gemApplyType = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: gemOffset of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_gemOffset
static int tolua_get_BaseItem_gemOffset(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gemOffset'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->gemOffset);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: gemOffset of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_gemOffset
static int tolua_set_BaseItem_gemOffset(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gemOffset'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->gemOffset = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: gemSockets of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_gemSockets
static int tolua_get_BaseItem_gemSockets(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gemSockets'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->gemSockets);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: gemSockets of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_gemSockets
static int tolua_set_BaseItem_gemSockets(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gemSockets'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->gemSockets = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: gheedMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_gheedMagicLvl
static int tolua_get_BaseItem_gheedMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gheedMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->gheedMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: gheedMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_gheedMagicLvl
static int tolua_set_BaseItem_gheedMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gheedMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->gheedMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: gheedMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_gheedMagicMax
static int tolua_get_BaseItem_gheedMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gheedMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->gheedMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: gheedMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_gheedMagicMax
static int tolua_set_BaseItem_gheedMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gheedMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->gheedMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: gheedMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_gheedMagicMin
static int tolua_get_BaseItem_gheedMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gheedMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->gheedMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: gheedMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_gheedMagicMin
static int tolua_set_BaseItem_gheedMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gheedMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->gheedMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: gheedMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_gheedMax
static int tolua_get_BaseItem_gheedMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gheedMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->gheedMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: gheedMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_gheedMax
static int tolua_set_BaseItem_gheedMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gheedMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->gheedMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: gheedMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_gheedMin
static int tolua_get_BaseItem_gheedMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gheedMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->gheedMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: gheedMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_gheedMin
static int tolua_set_BaseItem_gheedMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'gheedMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->gheedMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: halbuMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_halbuMagicLvl
static int tolua_get_BaseItem_halbuMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'halbuMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->halbuMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: halbuMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_halbuMagicLvl
static int tolua_set_BaseItem_halbuMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'halbuMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->halbuMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: halbuMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_halbuMagicMax
static int tolua_get_BaseItem_halbuMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'halbuMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->halbuMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: halbuMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_halbuMagicMax
static int tolua_set_BaseItem_halbuMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'halbuMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->halbuMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: halbuMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_halbuMagicMin
static int tolua_get_BaseItem_halbuMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'halbuMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->halbuMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: halbuMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_halbuMagicMin
static int tolua_set_BaseItem_halbuMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'halbuMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->halbuMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: halbuMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_halbuMax
static int tolua_get_BaseItem_halbuMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'halbuMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->halbuMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: halbuMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_halbuMax
static int tolua_set_BaseItem_halbuMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'halbuMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->halbuMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: halbuMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_halbuMin
static int tolua_get_BaseItem_halbuMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'halbuMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->halbuMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: halbuMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_halbuMin
static int tolua_set_BaseItem_halbuMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'halbuMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->halbuMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: hasInv of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_hasInv
static int tolua_get_BaseItem_hasInv(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'hasInv'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->hasInv);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: hasInv of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_hasInv
static int tolua_set_BaseItem_hasInv(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'hasInv'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->hasInv = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: hraltiMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_hraltiMagicLvl
static int tolua_get_BaseItem_hraltiMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'hraltiMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->hraltiMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: hraltiMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_hraltiMagicLvl
static int tolua_set_BaseItem_hraltiMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'hraltiMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->hraltiMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: hraltiMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_hraltiMagicMax
static int tolua_get_BaseItem_hraltiMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'hraltiMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->hraltiMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: hraltiMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_hraltiMagicMax
static int tolua_set_BaseItem_hraltiMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'hraltiMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->hraltiMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: hraltiMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_hraltiMagicMin
static int tolua_get_BaseItem_hraltiMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'hraltiMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->hraltiMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: hraltiMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_hraltiMagicMin
static int tolua_set_BaseItem_hraltiMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'hraltiMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->hraltiMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: hraltiMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_hraltiMax
static int tolua_get_BaseItem_hraltiMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'hraltiMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->hraltiMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: hraltiMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_hraltiMax
static int tolua_set_BaseItem_hraltiMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'hraltiMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->hraltiMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: hraltiMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_hraltiMin
static int tolua_get_BaseItem_hraltiMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'hraltiMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->hraltiMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: hraltiMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_hraltiMin
static int tolua_set_BaseItem_hraltiMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'hraltiMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->hraltiMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: invFile of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_invFile
static int tolua_get_BaseItem_invFile(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'invFile'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->invFile);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: invFile of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_invFile
static int tolua_set_BaseItem_invFile(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'invFile'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->invFile = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: invHeight of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_invHeight
static int tolua_get_BaseItem_invHeight(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'invHeight'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->invHeight);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: invHeight of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_invHeight
static int tolua_set_BaseItem_invHeight(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'invHeight'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->invHeight = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: invTrans of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_invTrans
static int tolua_get_BaseItem_invTrans(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'invTrans'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->invTrans);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: invTrans of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_invTrans
static int tolua_set_BaseItem_invTrans(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'invTrans'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->invTrans = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: invWidth of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_invWidth
static int tolua_get_BaseItem_invWidth(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'invWidth'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->invWidth);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: invWidth of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_invWidth
static int tolua_set_BaseItem_invWidth(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'invWidth'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->invWidth = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: jamellaMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_jamellaMagicLvl
static int tolua_get_BaseItem_jamellaMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'jamellaMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->jamellaMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: jamellaMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_jamellaMagicLvl
static int tolua_set_BaseItem_jamellaMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'jamellaMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->jamellaMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: jamellaMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_jamellaMagicMax
static int tolua_get_BaseItem_jamellaMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'jamellaMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->jamellaMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: jamellaMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_jamellaMagicMax
static int tolua_set_BaseItem_jamellaMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'jamellaMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->jamellaMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: jamellaMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_jamellaMagicMin
static int tolua_get_BaseItem_jamellaMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'jamellaMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->jamellaMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: jamellaMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_jamellaMagicMin
static int tolua_set_BaseItem_jamellaMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'jamellaMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->jamellaMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: jamellaMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_jamellaMax
static int tolua_get_BaseItem_jamellaMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'jamellaMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->jamellaMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: jamellaMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_jamellaMax
static int tolua_set_BaseItem_jamellaMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'jamellaMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->jamellaMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: jamellaMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_jamellaMin
static int tolua_get_BaseItem_jamellaMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'jamellaMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->jamellaMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: jamellaMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_jamellaMin
static int tolua_set_BaseItem_jamellaMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'jamellaMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->jamellaMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: larzukMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_larzukMagicLvl
static int tolua_get_BaseItem_larzukMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'larzukMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->larzukMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: larzukMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_larzukMagicLvl
static int tolua_set_BaseItem_larzukMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'larzukMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->larzukMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: larzukMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_larzukMagicMax
static int tolua_get_BaseItem_larzukMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'larzukMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->larzukMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: larzukMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_larzukMagicMax
static int tolua_set_BaseItem_larzukMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'larzukMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->larzukMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: larzukMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_larzukMagicMin
static int tolua_get_BaseItem_larzukMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'larzukMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->larzukMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: larzukMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_larzukMagicMin
static int tolua_set_BaseItem_larzukMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'larzukMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->larzukMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: larzukMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_larzukMax
static int tolua_get_BaseItem_larzukMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'larzukMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->larzukMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: larzukMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_larzukMax
static int tolua_set_BaseItem_larzukMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'larzukMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->larzukMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: larzukMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_larzukMin
static int tolua_get_BaseItem_larzukMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'larzukMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->larzukMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: larzukMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_larzukMin
static int tolua_set_BaseItem_larzukMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'larzukMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->larzukMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: level of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_level
static int tolua_get_BaseItem_level(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'level'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->level);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: level of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_level
static int tolua_set_BaseItem_level(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'level'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->level = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: levelReq of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_levelReq
static int tolua_get_BaseItem_levelReq(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'levelReq'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->levelReq);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: levelReq of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_levelReq
static int tolua_set_BaseItem_levelReq(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'levelReq'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->levelReq = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: lightRadius of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_lightRadius
static int tolua_get_BaseItem_lightRadius(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'lightRadius'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->lightRadius);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: lightRadius of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_lightRadius
static int tolua_set_BaseItem_lightRadius(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'lightRadius'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->lightRadius = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: lysanderMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_lysanderMagicLvl
static int tolua_get_BaseItem_lysanderMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'lysanderMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->lysanderMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: lysanderMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_lysanderMagicLvl
static int tolua_set_BaseItem_lysanderMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'lysanderMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->lysanderMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: lysanderMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_lysanderMagicMax
static int tolua_get_BaseItem_lysanderMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'lysanderMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->lysanderMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: lysanderMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_lysanderMagicMax
static int tolua_set_BaseItem_lysanderMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'lysanderMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->lysanderMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: lysanderMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_lysanderMagicMin
static int tolua_get_BaseItem_lysanderMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'lysanderMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->lysanderMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: lysanderMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_lysanderMagicMin
static int tolua_set_BaseItem_lysanderMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'lysanderMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->lysanderMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: lysanderMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_lysanderMax
static int tolua_get_BaseItem_lysanderMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'lysanderMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->lysanderMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: lysanderMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_lysanderMax
static int tolua_set_BaseItem_lysanderMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'lysanderMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->lysanderMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: lysanderMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_lysanderMin
static int tolua_get_BaseItem_lysanderMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'lysanderMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->lysanderMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: lysanderMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_lysanderMin
static int tolua_set_BaseItem_lysanderMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'lysanderMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->lysanderMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: malahMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_malahMagicLvl
static int tolua_get_BaseItem_malahMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'malahMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->malahMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: malahMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_malahMagicLvl
static int tolua_set_BaseItem_malahMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'malahMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->malahMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: malahMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_malahMagicMax
static int tolua_get_BaseItem_malahMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'malahMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->malahMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: malahMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_malahMagicMax
static int tolua_set_BaseItem_malahMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'malahMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->malahMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: malahMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_malahMagicMin
static int tolua_get_BaseItem_malahMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'malahMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->malahMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: malahMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_malahMagicMin
static int tolua_set_BaseItem_malahMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'malahMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->malahMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: malahMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_malahMax
static int tolua_get_BaseItem_malahMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'malahMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->malahMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: malahMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_malahMax
static int tolua_set_BaseItem_malahMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'malahMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->malahMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: malahMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_malahMin
static int tolua_get_BaseItem_malahMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'malahMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->malahMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: malahMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_malahMin
static int tolua_set_BaseItem_malahMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'malahMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->malahMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: maxDamage of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_maxDamage
static int tolua_get_BaseItem_maxDamage(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'maxDamage'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->maxDamage);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: maxDamage of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_maxDamage
static int tolua_set_BaseItem_maxDamage(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'maxDamage'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->maxDamage = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: maxStack of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_maxStack
static int tolua_get_BaseItem_maxStack(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'maxStack'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->maxStack);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: maxStack of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_maxStack
static int tolua_set_BaseItem_maxStack(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'maxStack'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->maxStack = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: minDamage of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_minDamage
static int tolua_get_BaseItem_minDamage(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'minDamage'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->minDamage);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: minDamage of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_minDamage
static int tolua_set_BaseItem_minDamage(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'minDamage'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->minDamage = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: minStack of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_minStack
static int tolua_get_BaseItem_minStack(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'minStack'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->minStack);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: minStack of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_minStack
static int tolua_set_BaseItem_minStack(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'minStack'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->minStack = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: missileType of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_missileType
static int tolua_get_BaseItem_missileType(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'missileType'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->missileType);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: missileType of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_missileType
static int tolua_set_BaseItem_missileType(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'missileType'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->missileType = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: name of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_name
static int tolua_get_BaseItem_name(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->name);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: name of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_name
static int tolua_set_BaseItem_name(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->name = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: nameable of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_nameable
static int tolua_get_BaseItem_nameable(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'nameable'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->nameable);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: nameable of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_nameable
static int tolua_set_BaseItem_nameable(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'nameable'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->nameable = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: nameString of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_nameString
static int tolua_get_BaseItem_nameString(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'nameString'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->nameString);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: nameString of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_nameString
static int tolua_set_BaseItem_nameString(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'nameString'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->nameString = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: noDurability of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_noDurability
static int tolua_get_BaseItem_noDurability(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'noDurability'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->noDurability);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: noDurability of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_noDurability
static int tolua_set_BaseItem_noDurability(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'noDurability'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->noDurability = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ormusMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_ormusMagicLvl
static int tolua_get_BaseItem_ormusMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ormusMagicLvl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->ormusMagicLvl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ormusMagicLvl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_ormusMagicLvl
static int tolua_set_BaseItem_ormusMagicLvl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ormusMagicLvl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ormusMagicLvl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ormusMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_ormusMagicMax
static int tolua_get_BaseItem_ormusMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ormusMagicMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->ormusMagicMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ormusMagicMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_ormusMagicMax
static int tolua_set_BaseItem_ormusMagicMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ormusMagicMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ormusMagicMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ormusMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_ormusMagicMin
static int tolua_get_BaseItem_ormusMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ormusMagicMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->ormusMagicMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ormusMagicMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_ormusMagicMin
static int tolua_set_BaseItem_ormusMagicMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ormusMagicMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ormusMagicMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ormusMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_ormusMax
static int tolua_get_BaseItem_ormusMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ormusMax'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->ormusMax);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ormusMax of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_ormusMax
static int tolua_set_BaseItem_ormusMax(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ormusMax'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ormusMax = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ormusMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_ormusMin
static int tolua_get_BaseItem_ormusMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ormusMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->ormusMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ormusMin of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_ormusMin
static int tolua_set_BaseItem_ormusMin(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ormusMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ormusMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: quantityWarning of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_quantityWarning
static int tolua_get_BaseItem_quantityWarning(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'quantityWarning'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->quantityWarning);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: quantityWarning of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_quantityWarning
static int tolua_set_BaseItem_quantityWarning(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'quantityWarning'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->quantityWarning = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: quest of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_quest
static int tolua_get_BaseItem_quest(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'quest'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->quest);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: quest of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_quest
static int tolua_set_BaseItem_quest(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'quest'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->quest = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: rarity of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_rarity
static int tolua_get_BaseItem_rarity(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'rarity'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->rarity);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: rarity of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_rarity
static int tolua_set_BaseItem_rarity(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'rarity'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->rarity = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: skipName of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_skipName
static int tolua_get_BaseItem_skipName(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'skipName'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->skipName);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: skipName of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_skipName
static int tolua_set_BaseItem_skipName(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'skipName'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->skipName = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: sourceArt of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_sourceArt
static int tolua_get_BaseItem_sourceArt(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'sourceArt'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->sourceArt);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: sourceArt of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_sourceArt
static int tolua_set_BaseItem_sourceArt(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'sourceArt'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->sourceArt = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: spawnable of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_spawnable
static int tolua_get_BaseItem_spawnable(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'spawnable'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->spawnable);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: spawnable of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_spawnable
static int tolua_set_BaseItem_spawnable(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'spawnable'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->spawnable = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: speed of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_speed
static int tolua_get_BaseItem_speed(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'speed'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->speed);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: speed of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_speed
static int tolua_set_BaseItem_speed(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'speed'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->speed = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: stackable of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_stackable
static int tolua_get_BaseItem_stackable(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stackable'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->stackable);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: stackable of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_stackable
static int tolua_set_BaseItem_stackable(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stackable'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->stackable = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: transform of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_transform
static int tolua_get_BaseItem_transform(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'transform'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->transform);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: transform of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_transform
static int tolua_set_BaseItem_transform(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'transform'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->transform = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: transparent of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_transparent
static int tolua_get_BaseItem_transparent(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'transparent'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->transparent);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: transparent of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_transparent
static int tolua_set_BaseItem_transparent(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'transparent'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->transparent = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: transTbl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_transTbl
static int tolua_get_BaseItem_transTbl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'transTbl'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->transTbl);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: transTbl of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_transTbl
static int tolua_set_BaseItem_transTbl(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'transTbl'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->transTbl = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: unique of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_unique
static int tolua_get_BaseItem_unique(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'unique'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->unique);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: unique of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_unique
static int tolua_set_BaseItem_unique(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'unique'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->unique = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: uniqueInvFile of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_uniqueInvFile
static int tolua_get_BaseItem_uniqueInvFile(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'uniqueInvFile'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->uniqueInvFile);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: uniqueInvFile of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_uniqueInvFile
static int tolua_set_BaseItem_uniqueInvFile(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'uniqueInvFile'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->uniqueInvFile = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: useable of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_useable
static int tolua_get_BaseItem_useable(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'useable'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->useable);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: useable of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_useable
static int tolua_set_BaseItem_useable(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'useable'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->useable = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: useSound of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_useSound
static int tolua_get_BaseItem_useSound(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'useSound'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->useSound);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: useSound of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_useSound
static int tolua_set_BaseItem_useSound(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'useSound'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->useSound = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: version of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseItem_version
static int tolua_get_BaseItem_version(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'version'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->version);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: version of class  BaseItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseItem_version
static int tolua_set_BaseItem_version(lua_State* tolua_S)
{
  BaseItem* self = (BaseItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'version'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->version = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Type of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_Type
static int tolua_get_BaseStat_Type(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Type);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Type of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_Type
static int tolua_set_BaseStat_Type(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Type = ((StatType::StatType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Index of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_Index
static int tolua_get_BaseStat_Index(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Index);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Index of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_Index
static int tolua_set_BaseStat_Index(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Index = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: TableIndex of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_TableIndex
static int tolua_get_BaseStat_TableIndex(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TableIndex'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->TableIndex);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: TableIndex of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_TableIndex
static int tolua_set_BaseStat_TableIndex(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TableIndex'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->TableIndex = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Name of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_Name
static int tolua_get_BaseStat_Name(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Name);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Name of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_Name
static int tolua_set_BaseStat_Name(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Name = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Stat of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_Stat
static int tolua_get_BaseStat_Stat(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Stat);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Stat of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_Stat
static int tolua_set_BaseStat_Stat(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Stat = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: SendOther of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_SendOther
static int tolua_get_BaseStat_SendOther(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SendOther'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->SendOther);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: SendOther of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_SendOther
static int tolua_set_BaseStat_SendOther(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SendOther'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->SendOther = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Signed of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_Signed
static int tolua_get_BaseStat_Signed(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Signed'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->Signed);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Signed of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_Signed
static int tolua_set_BaseStat_Signed(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Signed'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Signed = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: SendBits of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_SendBits
static int tolua_get_BaseStat_SendBits(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SendBits'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->SendBits);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: SendBits of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_SendBits
static int tolua_set_BaseStat_SendBits(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SendBits'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->SendBits = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: SendParamBits of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_SendParamBits
static int tolua_get_BaseStat_SendParamBits(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SendParamBits'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->SendParamBits);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: SendParamBits of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_SendParamBits
static int tolua_set_BaseStat_SendParamBits(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SendParamBits'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->SendParamBits = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: UpdateAnimRate of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_UpdateAnimRate
static int tolua_get_BaseStat_UpdateAnimRate(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'UpdateAnimRate'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->UpdateAnimRate);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: UpdateAnimRate of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_UpdateAnimRate
static int tolua_set_BaseStat_UpdateAnimRate(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'UpdateAnimRate'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->UpdateAnimRate = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Saved of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_Saved
static int tolua_get_BaseStat_Saved(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Saved'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Saved);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Saved of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_Saved
static int tolua_set_BaseStat_Saved(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Saved'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Saved = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: CSvSigned of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_CSvSigned
static int tolua_get_BaseStat_CSvSigned(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CSvSigned'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->CSvSigned);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: CSvSigned of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_CSvSigned
static int tolua_set_BaseStat_CSvSigned(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CSvSigned'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->CSvSigned = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: CSvBits of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_CSvBits
static int tolua_get_BaseStat_CSvBits(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CSvBits'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->CSvBits);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: CSvBits of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_CSvBits
static int tolua_set_BaseStat_CSvBits(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CSvBits'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->CSvBits = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: CSvParam of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_CSvParam
static int tolua_get_BaseStat_CSvParam(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CSvParam'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->CSvParam);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: CSvParam of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_CSvParam
static int tolua_set_BaseStat_CSvParam(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CSvParam'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->CSvParam = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: fCallback of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_fCallback
static int tolua_get_BaseStat_fCallback(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'fCallback'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->fCallback);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: fCallback of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_fCallback
static int tolua_set_BaseStat_fCallback(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'fCallback'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->fCallback = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: fMin of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_fMin
static int tolua_get_BaseStat_fMin(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'fMin'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->fMin);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: fMin of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_fMin
static int tolua_set_BaseStat_fMin(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'fMin'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->fMin = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: MinAccr of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_MinAccr
static int tolua_get_BaseStat_MinAccr(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MinAccr'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->MinAccr);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: MinAccr of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_MinAccr
static int tolua_set_BaseStat_MinAccr(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MinAccr'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->MinAccr = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Encode of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_Encode
static int tolua_get_BaseStat_Encode(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Encode'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Encode);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Encode of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_Encode
static int tolua_set_BaseStat_Encode(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Encode'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Encode = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Add of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_Add
static int tolua_get_BaseStat_Add(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Add'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Add);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Add of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_Add
static int tolua_set_BaseStat_Add(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Add'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Add = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Multiply of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_Multiply
static int tolua_get_BaseStat_Multiply(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Multiply'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Multiply);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Multiply of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_Multiply
static int tolua_set_BaseStat_Multiply(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Multiply'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Multiply = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Divide of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_Divide
static int tolua_get_BaseStat_Divide(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Divide'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Divide);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Divide of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_Divide
static int tolua_set_BaseStat_Divide(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Divide'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Divide = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ValShift of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_ValShift
static int tolua_get_BaseStat_ValShift(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ValShift'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->ValShift);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ValShift of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_ValShift
static int tolua_set_BaseStat_ValShift(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ValShift'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ValShift = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: SaveBits_1_09 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_SaveBits_1_09
static int tolua_get_BaseStat_SaveBits_1_09(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SaveBits_1_09'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->SaveBits_1_09);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: SaveBits_1_09 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_SaveBits_1_09
static int tolua_set_BaseStat_SaveBits_1_09(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SaveBits_1_09'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->SaveBits_1_09 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: SaveAdd_1_09 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_SaveAdd_1_09
static int tolua_get_BaseStat_SaveAdd_1_09(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SaveAdd_1_09'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->SaveAdd_1_09);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: SaveAdd_1_09 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_SaveAdd_1_09
static int tolua_set_BaseStat_SaveAdd_1_09(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SaveAdd_1_09'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->SaveAdd_1_09 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: SaveBits of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_SaveBits
static int tolua_get_BaseStat_SaveBits(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SaveBits'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->SaveBits);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: SaveBits of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_SaveBits
static int tolua_set_BaseStat_SaveBits(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SaveBits'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->SaveBits = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: SaveAdd of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_SaveAdd
static int tolua_get_BaseStat_SaveAdd(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SaveAdd'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->SaveAdd);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: SaveAdd of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_SaveAdd
static int tolua_set_BaseStat_SaveAdd(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SaveAdd'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->SaveAdd = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: SaveParamBits of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_SaveParamBits
static int tolua_get_BaseStat_SaveParamBits(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SaveParamBits'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->SaveParamBits);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: SaveParamBits of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_SaveParamBits
static int tolua_set_BaseStat_SaveParamBits(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'SaveParamBits'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->SaveParamBits = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: KeepZero of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_KeepZero
static int tolua_get_BaseStat_KeepZero(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'KeepZero'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->KeepZero);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: KeepZero of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_KeepZero
static int tolua_set_BaseStat_KeepZero(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'KeepZero'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->KeepZero = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Op of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_Op
static int tolua_get_BaseStat_Op(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Op'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Op);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Op of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_Op
static int tolua_set_BaseStat_Op(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Op'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Op = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: OpParam of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_OpParam
static int tolua_get_BaseStat_OpParam(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'OpParam'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->OpParam);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: OpParam of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_OpParam
static int tolua_set_BaseStat_OpParam(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'OpParam'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->OpParam = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: OpBase of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_OpBase
static int tolua_get_BaseStat_OpBase(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'OpBase'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->OpBase);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: OpBase of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_OpBase
static int tolua_set_BaseStat_OpBase(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'OpBase'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->OpBase = ((StatType::StatType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: OpStat1 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_OpStat1
static int tolua_get_BaseStat_OpStat1(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'OpStat1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->OpStat1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: OpStat1 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_OpStat1
static int tolua_set_BaseStat_OpStat1(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'OpStat1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->OpStat1 = ((StatType::StatType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: OpStat2 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_OpStat2
static int tolua_get_BaseStat_OpStat2(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'OpStat2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->OpStat2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: OpStat2 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_OpStat2
static int tolua_set_BaseStat_OpStat2(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'OpStat2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->OpStat2 = ((StatType::StatType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: OpStat3 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_OpStat3
static int tolua_get_BaseStat_OpStat3(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'OpStat3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->OpStat3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: OpStat3 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_OpStat3
static int tolua_set_BaseStat_OpStat3(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'OpStat3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->OpStat3 = ((StatType::StatType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Direct of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_Direct
static int tolua_get_BaseStat_Direct(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Direct'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->Direct);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Direct of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_Direct
static int tolua_set_BaseStat_Direct(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Direct'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Direct = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: MaxStat of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_MaxStat
static int tolua_get_BaseStat_MaxStat(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxStat'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->MaxStat);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: MaxStat of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_MaxStat
static int tolua_set_BaseStat_MaxStat(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxStat'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->MaxStat = ((StatType::StatType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ItemSpecific of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_ItemSpecific
static int tolua_get_BaseStat_ItemSpecific(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ItemSpecific'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->ItemSpecific);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ItemSpecific of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_ItemSpecific
static int tolua_set_BaseStat_ItemSpecific(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ItemSpecific'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ItemSpecific = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DamageRelated of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_DamageRelated
static int tolua_get_BaseStat_DamageRelated(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DamageRelated'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->DamageRelated);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DamageRelated of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_DamageRelated
static int tolua_set_BaseStat_DamageRelated(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DamageRelated'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DamageRelated = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ItemEvent1 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_ItemEvent1
static int tolua_get_BaseStat_ItemEvent1(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ItemEvent1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->ItemEvent1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ItemEvent1 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_ItemEvent1
static int tolua_set_BaseStat_ItemEvent1(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ItemEvent1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ItemEvent1 = ((ItemEventType::ItemEventType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ItemEventFunc1 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_ItemEventFunc1
static int tolua_get_BaseStat_ItemEventFunc1(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ItemEventFunc1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->ItemEventFunc1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ItemEventFunc1 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_ItemEventFunc1
static int tolua_set_BaseStat_ItemEventFunc1(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ItemEventFunc1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ItemEventFunc1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ItemEvent2 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_ItemEvent2
static int tolua_get_BaseStat_ItemEvent2(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ItemEvent2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->ItemEvent2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ItemEvent2 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_ItemEvent2
static int tolua_set_BaseStat_ItemEvent2(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ItemEvent2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ItemEvent2 = ((ItemEventType::ItemEventType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ItemEventFunc2 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_ItemEventFunc2
static int tolua_get_BaseStat_ItemEventFunc2(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ItemEventFunc2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->ItemEventFunc2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ItemEventFunc2 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_ItemEventFunc2
static int tolua_set_BaseStat_ItemEventFunc2(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ItemEventFunc2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ItemEventFunc2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DescPriority of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_DescPriority
static int tolua_get_BaseStat_DescPriority(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DescPriority'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->DescPriority);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DescPriority of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_DescPriority
static int tolua_set_BaseStat_DescPriority(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DescPriority'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DescPriority = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DescFunc of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_DescFunc
static int tolua_get_BaseStat_DescFunc(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DescFunc'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->DescFunc);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DescFunc of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_DescFunc
static int tolua_set_BaseStat_DescFunc(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DescFunc'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DescFunc = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DescVal of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_DescVal
static int tolua_get_BaseStat_DescVal(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DescVal'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->DescVal);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DescVal of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_DescVal
static int tolua_set_BaseStat_DescVal(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DescVal'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DescVal = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DescStrPos of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_DescStrPos
static int tolua_get_BaseStat_DescStrPos(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DescStrPos'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->DescStrPos);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DescStrPos of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_DescStrPos
static int tolua_set_BaseStat_DescStrPos(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DescStrPos'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DescStrPos = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DescStrNeg of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_DescStrNeg
static int tolua_get_BaseStat_DescStrNeg(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DescStrNeg'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->DescStrNeg);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DescStrNeg of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_DescStrNeg
static int tolua_set_BaseStat_DescStrNeg(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DescStrNeg'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DescStrNeg = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DescStr2 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_DescStr2
static int tolua_get_BaseStat_DescStr2(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DescStr2'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->DescStr2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DescStr2 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_DescStr2
static int tolua_set_BaseStat_DescStr2(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DescStr2'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DescStr2 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DGrp of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_DGrp
static int tolua_get_BaseStat_DGrp(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DGrp'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->DGrp);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DGrp of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_DGrp
static int tolua_set_BaseStat_DGrp(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DGrp'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DGrp = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DGrpFunc of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_DGrpFunc
static int tolua_get_BaseStat_DGrpFunc(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DGrpFunc'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->DGrpFunc);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DGrpFunc of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_DGrpFunc
static int tolua_set_BaseStat_DGrpFunc(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DGrpFunc'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DGrpFunc = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DGrpval of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_DGrpval
static int tolua_get_BaseStat_DGrpval(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DGrpval'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->DGrpval);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DGrpval of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_DGrpval
static int tolua_set_BaseStat_DGrpval(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DGrpval'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DGrpval = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DGrpStrPos of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_DGrpStrPos
static int tolua_get_BaseStat_DGrpStrPos(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DGrpStrPos'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->DGrpStrPos);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DGrpStrPos of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_DGrpStrPos
static int tolua_set_BaseStat_DGrpStrPos(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DGrpStrPos'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DGrpStrPos = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DGrpStrNeg of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_DGrpStrNeg
static int tolua_get_BaseStat_DGrpStrNeg(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DGrpStrNeg'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->DGrpStrNeg);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DGrpStrNeg of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_DGrpStrNeg
static int tolua_set_BaseStat_DGrpStrNeg(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DGrpStrNeg'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DGrpStrNeg = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DGrpStr2 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_DGrpStr2
static int tolua_get_BaseStat_DGrpStr2(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DGrpStr2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->DGrpStr2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DGrpStr2 of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_DGrpStr2
static int tolua_set_BaseStat_DGrpStr2(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DGrpStr2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DGrpStr2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Stuff of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_get_BaseStat_Stuff
static int tolua_get_BaseStat_Stuff(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stuff'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Stuff);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Stuff of class  BaseStat */
#ifndef TOLUA_DISABLE_tolua_set_BaseStat_Stuff
static int tolua_set_BaseStat_Stuff(lua_State* tolua_S)
{
  BaseStat* self = (BaseStat*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stuff'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Stuff = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Stat of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_Stat_ptr
static int tolua_get_StatBase_Stat_ptr(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Stat,"BaseStat");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Stat of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_Stat_ptr
static int tolua_set_StatBase_Stat_ptr(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseStat",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Stat = ((BaseStat*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Value of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_unsigned_Value
static int tolua_get_StatBase_unsigned_Value(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Value'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Value);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Value of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_unsigned_Value
static int tolua_set_StatBase_unsigned_Value(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Value'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Value = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_unsigned_Param
static int tolua_get_StatBase_unsigned_Param(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_unsigned_Param
static int tolua_set_StatBase_unsigned_Param(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Skill of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_Skill
static int tolua_get_StatBase_Skill(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Skill'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->Skill,"SkillType::SkillType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Skill of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_Skill
static int tolua_set_StatBase_Skill(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Skill'",NULL);
  if (!tolua_isusertype(tolua_S,2,"SkillType::SkillType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Skill = *((SkillType::SkillType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Monster of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_Monster
static int tolua_get_StatBase_Monster(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Monster'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->Monster,"NPCCode::NPCCode");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Monster of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_Monster
static int tolua_set_StatBase_Monster(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Monster'",NULL);
  if (!tolua_isusertype(tolua_S,2,"NPCCode::NPCCode",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Monster = *((NPCCode::NPCCode*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Charges of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_Charges
static int tolua_get_StatBase_Charges(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Charges'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Charges);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Charges of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_Charges
static int tolua_set_StatBase_Charges(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Charges'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Charges = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: MaxCharges of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_MaxCharges
static int tolua_get_StatBase_MaxCharges(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxCharges'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->MaxCharges);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: MaxCharges of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_MaxCharges
static int tolua_set_StatBase_MaxCharges(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'MaxCharges'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->MaxCharges = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Chance of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_Chance
static int tolua_get_StatBase_Chance(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Chance'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Chance);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Chance of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_Chance
static int tolua_set_StatBase_Chance(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Chance'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Chance = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Event of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_Event
static int tolua_get_StatBase_Event(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Event'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Event);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Event of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_Event
static int tolua_set_StatBase_Event(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Event'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Event = ((ItemEventType::ItemEventType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Element of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_Element
static int tolua_get_StatBase_Element(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Element'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->Element,"DamageType::DamageType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Element of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_Element
static int tolua_set_StatBase_Element(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Element'",NULL);
  if (!tolua_isusertype(tolua_S,2,"DamageType::DamageType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Element = *((DamageType::DamageType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Class of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_Class
static int tolua_get_StatBase_Class(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Class'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->Class,"CharacterClass::CharacterClass");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Class of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_Class
static int tolua_set_StatBase_Class(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Class'",NULL);
  if (!tolua_isusertype(tolua_S,2,"CharacterClass::CharacterClass",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Class = *((CharacterClass::CharacterClass*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Tab of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_Tab
static int tolua_get_StatBase_Tab(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Tab'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->Tab,"SkillTab::SkillTab");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Tab of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_Tab
static int tolua_set_StatBase_Tab(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Tab'",NULL);
  if (!tolua_isusertype(tolua_S,2,"SkillTab::SkillTab",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Tab = *((SkillTab::SkillTab*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: TabNumber of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_TabNumber
static int tolua_get_StatBase_TabNumber(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TabNumber'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->TabNumber);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: TabNumber of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_TabNumber
static int tolua_set_StatBase_TabNumber(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'TabNumber'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->TabNumber = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Unknown of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_Unknown
static int tolua_get_StatBase_Unknown(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Unknown'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Unknown);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Unknown of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_Unknown
static int tolua_set_StatBase_Unknown(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Unknown'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Unknown = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PerLevel of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_PerLevel
static int tolua_get_StatBase_PerLevel(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PerLevel'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PerLevel);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PerLevel of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_PerLevel
static int tolua_set_StatBase_PerLevel(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PerLevel'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PerLevel = ((double)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Type of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_Type
static int tolua_get_StatBase_Type(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->Type,"DamageType::DamageType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Type of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_Type
static int tolua_set_StatBase_Type(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",NULL);
  if (!tolua_isusertype(tolua_S,2,"DamageType::DamageType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Type = *((DamageType::DamageType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: IsPercent of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_IsPercent
static int tolua_get_StatBase_IsPercent(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IsPercent'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->IsPercent);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: IsPercent of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_IsPercent
static int tolua_set_StatBase_IsPercent(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IsPercent'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->IsPercent = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Frames of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_Frames
static int tolua_get_StatBase_Frames(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Frames'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Frames);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Frames of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_Frames
static int tolua_set_StatBase_Frames(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Frames'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Frames = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Seconds of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_Seconds
static int tolua_get_StatBase_Seconds(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Seconds'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Seconds);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Seconds of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_Seconds
static int tolua_set_StatBase_Seconds(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Seconds'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Seconds = ((double)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_Min
static int tolua_get_StatBase_Min(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_Min
static int tolua_set_StatBase_Min(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_get_StatBase_Max
static int tolua_get_StatBase_Max(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max of class  StatBase */
#ifndef TOLUA_DISABLE_tolua_set_StatBase_Max
static int tolua_set_StatBase_Max(lua_State* tolua_S)
{
  StatBase* self = (StatBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: SuperiorPrefix of class  ItemNames */
#ifndef TOLUA_DISABLE_tolua_get_ItemNames_SuperiorPrefix
static int tolua_get_ItemNames_SuperiorPrefix(lua_State* tolua_S)
{
  tolua_pushcppstring(tolua_S,(const char*)ItemNames::SuperiorPrefix);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: InferiorPrefix of class  ItemNames */
#ifndef TOLUA_DISABLE_tolua_get_item_ItemNames_InferiorPrefix
static int tolua_get_item_ItemNames_InferiorPrefix(lua_State* tolua_S)
{
 int tolua_index;
#ifndef TOLUA_RELEASE
 {
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
 }
#endif
 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
#ifndef TOLUA_RELEASE
 if (tolua_index<0)
  tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
 tolua_pushcppstring(tolua_S,(const char*)ItemNames::InferiorPrefix[tolua_index]);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: RarePrefixOffset of class  ItemNames */
#ifndef TOLUA_DISABLE_tolua_get_ItemNames_RarePrefixOffset
static int tolua_get_ItemNames_RarePrefixOffset(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)ItemNames::RarePrefixOffset);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: RareSuffixOffset of class  ItemNames */
#ifndef TOLUA_DISABLE_tolua_get_ItemNames_RareSuffixOffset
static int tolua_get_ItemNames_RareSuffixOffset(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)ItemNames::RareSuffixOffset);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: RareAffix of class  ItemNames */
#ifndef TOLUA_DISABLE_tolua_get_item_ItemNames_RareAffix
static int tolua_get_item_ItemNames_RareAffix(lua_State* tolua_S)
{
 int tolua_index;
#ifndef TOLUA_RELEASE
 {
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
 }
#endif
 tolua_index = (int)tolua_tonumber(tolua_S,2,0);
#ifndef TOLUA_RELEASE
 if (tolua_index<0)
  tolua_error(tolua_S,"array indexing out of range.",NULL);
#endif
 tolua_pushcppstring(tolua_S,(const char*)ItemNames::RareAffix[tolua_index]);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Type of class  ItemAffix */
#ifndef TOLUA_DISABLE_tolua_get_ItemAffix_Type
static int tolua_get_ItemAffix_Type(lua_State* tolua_S)
{
  ItemAffix* self = (ItemAffix*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Type);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Type of class  ItemAffix */
#ifndef TOLUA_DISABLE_tolua_set_ItemAffix_Type
static int tolua_set_ItemAffix_Type(lua_State* tolua_S)
{
  ItemAffix* self = (ItemAffix*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Type = ((ItemAffixType::ItemAffixType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Index of class  ItemAffix */
#ifndef TOLUA_DISABLE_tolua_get_ItemAffix_Index
static int tolua_get_ItemAffix_Index(lua_State* tolua_S)
{
  ItemAffix* self = (ItemAffix*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Index);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Index of class  ItemAffix */
#ifndef TOLUA_DISABLE_tolua_set_ItemAffix_Index
static int tolua_set_ItemAffix_Index(lua_State* tolua_S)
{
  ItemAffix* self = (ItemAffix*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Index = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Name of class  ItemAffix */
#ifndef TOLUA_DISABLE_tolua_get_ItemAffix_Name
static int tolua_get_ItemAffix_Name(lua_State* tolua_S)
{
  ItemAffix* self = (ItemAffix*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Name);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Name of class  ItemAffix */
#ifndef TOLUA_DISABLE_tolua_set_ItemAffix_Name
static int tolua_set_ItemAffix_Name(lua_State* tolua_S)
{
  ItemAffix* self = (ItemAffix*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Name = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Index of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Index
static int tolua_get_BaseProperty_Index(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Index);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Index of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Index
static int tolua_set_BaseProperty_Index(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Index = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Code of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Code
static int tolua_get_BaseProperty_Code(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Code'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Code);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Code of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Code
static int tolua_set_BaseProperty_Code(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Code'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Code = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Done of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Done
static int tolua_get_BaseProperty_Done(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Done'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->Done);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Done of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Done
static int tolua_set_BaseProperty_Done(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Done'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Done = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Set1 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Set1
static int tolua_get_BaseProperty_Set1(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Set1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Set1 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Set1
static int tolua_set_BaseProperty_Set1(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Set1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Val1 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Val1
static int tolua_get_BaseProperty_Val1(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Val1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Val1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Val1 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Val1
static int tolua_set_BaseProperty_Val1(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Val1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Val1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Func1 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Func1
static int tolua_get_BaseProperty_Func1(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Func1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Func1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Func1 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Func1
static int tolua_set_BaseProperty_Func1(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Func1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Func1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Stat1 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Stat1
static int tolua_get_BaseProperty_Stat1(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Stat1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Stat1 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Stat1
static int tolua_set_BaseProperty_Stat1(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Stat1 = ((StatType::StatType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Set2 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Set2
static int tolua_get_BaseProperty_Set2(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Set2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Set2 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Set2
static int tolua_set_BaseProperty_Set2(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Set2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Val2 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Val2
static int tolua_get_BaseProperty_Val2(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Val2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Val2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Val2 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Val2
static int tolua_set_BaseProperty_Val2(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Val2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Val2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Func2 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Func2
static int tolua_get_BaseProperty_Func2(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Func2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Func2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Func2 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Func2
static int tolua_set_BaseProperty_Func2(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Func2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Func2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Stat2 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Stat2
static int tolua_get_BaseProperty_Stat2(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Stat2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Stat2 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Stat2
static int tolua_set_BaseProperty_Stat2(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Stat2 = ((StatType::StatType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Set3 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Set3
static int tolua_get_BaseProperty_Set3(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Set3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Set3 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Set3
static int tolua_set_BaseProperty_Set3(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Set3 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Val3 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Val3
static int tolua_get_BaseProperty_Val3(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Val3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Val3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Val3 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Val3
static int tolua_set_BaseProperty_Val3(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Val3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Val3 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Func3 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Func3
static int tolua_get_BaseProperty_Func3(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Func3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Func3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Func3 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Func3
static int tolua_set_BaseProperty_Func3(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Func3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Func3 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Stat3 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Stat3
static int tolua_get_BaseProperty_Stat3(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Stat3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Stat3 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Stat3
static int tolua_set_BaseProperty_Stat3(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Stat3 = ((StatType::StatType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Set4 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Set4
static int tolua_get_BaseProperty_Set4(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set4'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Set4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Set4 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Set4
static int tolua_set_BaseProperty_Set4(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set4'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Set4 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Val4 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Val4
static int tolua_get_BaseProperty_Val4(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Val4'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Val4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Val4 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Val4
static int tolua_set_BaseProperty_Val4(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Val4'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Val4 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Func4 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Func4
static int tolua_get_BaseProperty_Func4(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Func4'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Func4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Func4 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Func4
static int tolua_set_BaseProperty_Func4(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Func4'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Func4 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Stat4 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Stat4
static int tolua_get_BaseProperty_Stat4(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat4'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Stat4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Stat4 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Stat4
static int tolua_set_BaseProperty_Stat4(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat4'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Stat4 = ((StatType::StatType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Set5 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Set5
static int tolua_get_BaseProperty_Set5(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set5'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Set5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Set5 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Set5
static int tolua_set_BaseProperty_Set5(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set5'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Set5 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Val5 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Val5
static int tolua_get_BaseProperty_Val5(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Val5'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Val5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Val5 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Val5
static int tolua_set_BaseProperty_Val5(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Val5'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Val5 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Func5 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Func5
static int tolua_get_BaseProperty_Func5(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Func5'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Func5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Func5 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Func5
static int tolua_set_BaseProperty_Func5(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Func5'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Func5 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Stat5 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Stat5
static int tolua_get_BaseProperty_Stat5(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat5'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Stat5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Stat5 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Stat5
static int tolua_set_BaseProperty_Stat5(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat5'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Stat5 = ((StatType::StatType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Set6 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Set6
static int tolua_get_BaseProperty_Set6(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set6'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Set6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Set6 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Set6
static int tolua_set_BaseProperty_Set6(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set6'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Set6 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Val6 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Val6
static int tolua_get_BaseProperty_Val6(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Val6'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Val6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Val6 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Val6
static int tolua_set_BaseProperty_Val6(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Val6'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Val6 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Func6 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Func6
static int tolua_get_BaseProperty_Func6(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Func6'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Func6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Func6 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Func6
static int tolua_set_BaseProperty_Func6(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Func6'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Func6 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Stat6 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Stat6
static int tolua_get_BaseProperty_Stat6(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat6'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Stat6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Stat6 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Stat6
static int tolua_set_BaseProperty_Stat6(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat6'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Stat6 = ((StatType::StatType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Set7 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Set7
static int tolua_get_BaseProperty_Set7(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set7'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Set7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Set7 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Set7
static int tolua_set_BaseProperty_Set7(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set7'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Set7 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Val7 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Val7
static int tolua_get_BaseProperty_Val7(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Val7'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Val7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Val7 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Val7
static int tolua_set_BaseProperty_Val7(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Val7'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Val7 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Func7 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Func7
static int tolua_get_BaseProperty_Func7(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Func7'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Func7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Func7 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Func7
static int tolua_set_BaseProperty_Func7(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Func7'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Func7 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Stat7 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Stat7
static int tolua_get_BaseProperty_Stat7(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat7'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Stat7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Stat7 of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Stat7
static int tolua_set_BaseProperty_Stat7(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Stat7'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Stat7 = ((StatType::StatType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Desc of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Desc
static int tolua_get_BaseProperty_Desc(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Desc'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Desc);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Desc of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Desc
static int tolua_set_BaseProperty_Desc(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Desc'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Desc = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Param
static int tolua_get_BaseProperty_Param(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Param);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Param
static int tolua_set_BaseProperty_Param(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Min
static int tolua_get_BaseProperty_Min(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Min);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Min
static int tolua_set_BaseProperty_Min(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_get_BaseProperty_Max
static int tolua_get_BaseProperty_Max(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Max);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max of class  BaseProperty */
#ifndef TOLUA_DISABLE_tolua_set_BaseProperty_Max
static int tolua_set_BaseProperty_Max(lua_State* tolua_S)
{
  BaseProperty* self = (BaseProperty*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Index of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Index
static int tolua_get_BaseRuneword_Index(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Index);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Index of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Index
static int tolua_set_BaseRuneword_Index(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Index = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Id of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Id
static int tolua_get_BaseRuneword_Id(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Id'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Id);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Id of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Id
static int tolua_set_BaseRuneword_Id(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Id'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Id = ((RunewordType::RunewordType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Name of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Name
static int tolua_get_BaseRuneword_Name(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Name);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Name of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Name
static int tolua_set_BaseRuneword_Name(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Name = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Complete of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Complete
static int tolua_get_BaseRuneword_Complete(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Complete'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->Complete);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Complete of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Complete
static int tolua_set_BaseRuneword_Complete(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Complete'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Complete = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Server of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Server
static int tolua_get_BaseRuneword_Server(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Server'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->Server);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Server of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Server
static int tolua_set_BaseRuneword_Server(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Server'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Server = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: IType1 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_IType1_ptr
static int tolua_get_BaseRuneword_IType1_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IType1'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->IType1,"BaseItemType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: IType1 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_IType1_ptr
static int tolua_set_BaseRuneword_IType1_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IType1'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseItemType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->IType1 = ((BaseItemType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: IType2 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_IType2_ptr
static int tolua_get_BaseRuneword_IType2_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IType2'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->IType2,"BaseItemType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: IType2 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_IType2_ptr
static int tolua_set_BaseRuneword_IType2_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IType2'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseItemType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->IType2 = ((BaseItemType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: IType3 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_IType3_ptr
static int tolua_get_BaseRuneword_IType3_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IType3'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->IType3,"BaseItemType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: IType3 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_IType3_ptr
static int tolua_set_BaseRuneword_IType3_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IType3'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseItemType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->IType3 = ((BaseItemType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: IType4 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_IType4_ptr
static int tolua_get_BaseRuneword_IType4_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IType4'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->IType4,"BaseItemType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: IType4 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_IType4_ptr
static int tolua_set_BaseRuneword_IType4_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IType4'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseItemType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->IType4 = ((BaseItemType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: IType5 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_IType5_ptr
static int tolua_get_BaseRuneword_IType5_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IType5'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->IType5,"BaseItemType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: IType5 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_IType5_ptr
static int tolua_set_BaseRuneword_IType5_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IType5'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseItemType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->IType5 = ((BaseItemType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: IType6 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_IType6_ptr
static int tolua_get_BaseRuneword_IType6_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IType6'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->IType6,"BaseItemType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: IType6 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_IType6_ptr
static int tolua_set_BaseRuneword_IType6_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'IType6'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseItemType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->IType6 = ((BaseItemType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EType1 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_EType1_ptr
static int tolua_get_BaseRuneword_EType1_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EType1'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->EType1,"BaseItemType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EType1 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_EType1_ptr
static int tolua_set_BaseRuneword_EType1_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EType1'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseItemType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EType1 = ((BaseItemType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EType2 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_EType2_ptr
static int tolua_get_BaseRuneword_EType2_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EType2'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->EType2,"BaseItemType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EType2 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_EType2_ptr
static int tolua_set_BaseRuneword_EType2_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EType2'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseItemType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EType2 = ((BaseItemType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EType3 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_EType3_ptr
static int tolua_get_BaseRuneword_EType3_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EType3'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->EType3,"BaseItemType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EType3 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_EType3_ptr
static int tolua_set_BaseRuneword_EType3_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EType3'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseItemType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EType3 = ((BaseItemType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Runes of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Runes
static int tolua_get_BaseRuneword_Runes(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Runes'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Runes);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Runes of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Runes
static int tolua_set_BaseRuneword_Runes(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Runes'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Runes = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Rune1 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Rune1
static int tolua_get_BaseRuneword_Rune1(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rune1'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Rune1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Rune1 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Rune1
static int tolua_set_BaseRuneword_Rune1(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rune1'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Rune1 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Rune2 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Rune2
static int tolua_get_BaseRuneword_Rune2(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rune2'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Rune2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Rune2 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Rune2
static int tolua_set_BaseRuneword_Rune2(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rune2'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Rune2 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Rune3 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Rune3
static int tolua_get_BaseRuneword_Rune3(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rune3'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Rune3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Rune3 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Rune3
static int tolua_set_BaseRuneword_Rune3(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rune3'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Rune3 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Rune4 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Rune4
static int tolua_get_BaseRuneword_Rune4(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rune4'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Rune4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Rune4 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Rune4
static int tolua_set_BaseRuneword_Rune4(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rune4'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Rune4 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Rune5 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Rune5
static int tolua_get_BaseRuneword_Rune5(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rune5'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Rune5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Rune5 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Rune5
static int tolua_set_BaseRuneword_Rune5(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rune5'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Rune5 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Rune6 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Rune6
static int tolua_get_BaseRuneword_Rune6(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rune6'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Rune6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Rune6 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Rune6
static int tolua_set_BaseRuneword_Rune6(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rune6'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Rune6 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property1 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Property1_ptr
static int tolua_get_BaseRuneword_Property1_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property1'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property1,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property1 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Property1_ptr
static int tolua_set_BaseRuneword_Property1_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property1'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property1 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param1 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Param1
static int tolua_get_BaseRuneword_Param1(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param1 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Param1
static int tolua_set_BaseRuneword_Param1(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min1 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Min1
static int tolua_get_BaseRuneword_Min1(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min1 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Min1
static int tolua_set_BaseRuneword_Min1(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max1 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Max1
static int tolua_get_BaseRuneword_Max1(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max1 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Max1
static int tolua_set_BaseRuneword_Max1(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property2 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Property2_ptr
static int tolua_get_BaseRuneword_Property2_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property2'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property2,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property2 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Property2_ptr
static int tolua_set_BaseRuneword_Property2_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property2'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property2 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param2 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Param2
static int tolua_get_BaseRuneword_Param2(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param2 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Param2
static int tolua_set_BaseRuneword_Param2(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min2 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Min2
static int tolua_get_BaseRuneword_Min2(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min2 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Min2
static int tolua_set_BaseRuneword_Min2(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max2 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Max2
static int tolua_get_BaseRuneword_Max2(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max2 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Max2
static int tolua_set_BaseRuneword_Max2(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property3 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Property3_ptr
static int tolua_get_BaseRuneword_Property3_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property3'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property3,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property3 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Property3_ptr
static int tolua_set_BaseRuneword_Property3_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property3'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property3 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param3 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Param3
static int tolua_get_BaseRuneword_Param3(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param3 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Param3
static int tolua_set_BaseRuneword_Param3(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param3 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min3 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Min3
static int tolua_get_BaseRuneword_Min3(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min3 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Min3
static int tolua_set_BaseRuneword_Min3(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min3 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max3 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Max3
static int tolua_get_BaseRuneword_Max3(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max3 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Max3
static int tolua_set_BaseRuneword_Max3(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max3 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property4 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Property4_ptr
static int tolua_get_BaseRuneword_Property4_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property4'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property4,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property4 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Property4_ptr
static int tolua_set_BaseRuneword_Property4_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property4'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property4 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param4 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Param4
static int tolua_get_BaseRuneword_Param4(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param4'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param4 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Param4
static int tolua_set_BaseRuneword_Param4(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param4'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param4 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min4 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Min4
static int tolua_get_BaseRuneword_Min4(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min4'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min4 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Min4
static int tolua_set_BaseRuneword_Min4(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min4'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min4 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max4 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Max4
static int tolua_get_BaseRuneword_Max4(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max4'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max4 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Max4
static int tolua_set_BaseRuneword_Max4(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max4'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max4 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property5 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Property5_ptr
static int tolua_get_BaseRuneword_Property5_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property5'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property5,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property5 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Property5_ptr
static int tolua_set_BaseRuneword_Property5_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property5'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property5 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param5 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Param5
static int tolua_get_BaseRuneword_Param5(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param5'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param5 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Param5
static int tolua_set_BaseRuneword_Param5(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param5'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param5 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min5 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Min5
static int tolua_get_BaseRuneword_Min5(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min5'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min5 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Min5
static int tolua_set_BaseRuneword_Min5(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min5'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min5 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max5 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Max5
static int tolua_get_BaseRuneword_Max5(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max5'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max5 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Max5
static int tolua_set_BaseRuneword_Max5(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max5'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max5 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property6 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Property6_ptr
static int tolua_get_BaseRuneword_Property6_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property6'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property6,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property6 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Property6_ptr
static int tolua_set_BaseRuneword_Property6_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property6'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property6 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param6 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Param6
static int tolua_get_BaseRuneword_Param6(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param6'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param6 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Param6
static int tolua_set_BaseRuneword_Param6(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param6'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param6 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min6 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Min6
static int tolua_get_BaseRuneword_Min6(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min6'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min6 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Min6
static int tolua_set_BaseRuneword_Min6(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min6'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min6 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max6 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Max6
static int tolua_get_BaseRuneword_Max6(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max6'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max6 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Max6
static int tolua_set_BaseRuneword_Max6(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max6'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max6 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property7 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Property7_ptr
static int tolua_get_BaseRuneword_Property7_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property7'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property7,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property7 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Property7_ptr
static int tolua_set_BaseRuneword_Property7_ptr(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property7'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property7 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param7 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Param7
static int tolua_get_BaseRuneword_Param7(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param7'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param7 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Param7
static int tolua_set_BaseRuneword_Param7(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param7'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param7 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min7 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Min7
static int tolua_get_BaseRuneword_Min7(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min7'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min7 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Min7
static int tolua_set_BaseRuneword_Min7(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min7'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min7 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max7 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_get_BaseRuneword_Max7
static int tolua_get_BaseRuneword_Max7(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max7'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max7 of class  BaseRuneword */
#ifndef TOLUA_DISABLE_tolua_set_BaseRuneword_Max7
static int tolua_set_BaseRuneword_Max7(lua_State* tolua_S)
{
  BaseRuneword* self = (BaseRuneword*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max7'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max7 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Index of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Index
static int tolua_get_BaseUniqueItem_Index(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Index);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Index of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Index
static int tolua_set_BaseUniqueItem_Index(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Index = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Id of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Id
static int tolua_get_BaseUniqueItem_Id(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Id'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Id);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Id of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Id
static int tolua_set_BaseUniqueItem_Id(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Id'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Id = ((UniqueItemType::UniqueItemType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Name of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Name
static int tolua_get_BaseUniqueItem_Name(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Name);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Name of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Name
static int tolua_set_BaseUniqueItem_Name(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Name = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Item of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Item_ptr
static int tolua_get_BaseUniqueItem_Item_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Item'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Item,"BaseItem");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Item of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Item_ptr
static int tolua_set_BaseUniqueItem_Item_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Item'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseItem",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Item = ((BaseItem*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Version of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Version
static int tolua_get_BaseUniqueItem_Version(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Version'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Version);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Version of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Version
static int tolua_set_BaseUniqueItem_Version(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Version'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Version = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Enabled of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Enabled
static int tolua_get_BaseUniqueItem_Enabled(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Enabled'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Enabled);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Enabled of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Enabled
static int tolua_set_BaseUniqueItem_Enabled(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Enabled'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Enabled = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Ladder of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Ladder
static int tolua_get_BaseUniqueItem_Ladder(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Ladder'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Ladder);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Ladder of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Ladder
static int tolua_set_BaseUniqueItem_Ladder(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Ladder'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Ladder = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Rarity of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Rarity
static int tolua_get_BaseUniqueItem_Rarity(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rarity'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Rarity);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Rarity of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Rarity
static int tolua_set_BaseUniqueItem_Rarity(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rarity'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Rarity = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: NoLimit of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_NoLimit
static int tolua_get_BaseUniqueItem_NoLimit(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NoLimit'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->NoLimit);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: NoLimit of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_NoLimit
static int tolua_set_BaseUniqueItem_NoLimit(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'NoLimit'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->NoLimit = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DropLevel of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_DropLevel
static int tolua_get_BaseUniqueItem_DropLevel(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DropLevel'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->DropLevel);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DropLevel of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_DropLevel
static int tolua_set_BaseUniqueItem_DropLevel(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DropLevel'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DropLevel = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: RequiredLevel of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_RequiredLevel
static int tolua_get_BaseUniqueItem_RequiredLevel(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'RequiredLevel'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->RequiredLevel);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: RequiredLevel of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_RequiredLevel
static int tolua_set_BaseUniqueItem_RequiredLevel(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'RequiredLevel'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->RequiredLevel = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: BaseItemName of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_BaseItemName
static int tolua_get_BaseUniqueItem_BaseItemName(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'BaseItemName'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->BaseItemName);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: BaseItemName of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_BaseItemName
static int tolua_set_BaseUniqueItem_BaseItemName(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'BaseItemName'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->BaseItemName = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Uber of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Uber
static int tolua_get_BaseUniqueItem_Uber(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Uber'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Uber);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Uber of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Uber
static int tolua_set_BaseUniqueItem_Uber(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Uber'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Uber = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Carry1 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Carry1
static int tolua_get_BaseUniqueItem_Carry1(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Carry1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Carry1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Carry1 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Carry1
static int tolua_set_BaseUniqueItem_Carry1(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Carry1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Carry1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: CostMultiply of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_CostMultiply
static int tolua_get_BaseUniqueItem_CostMultiply(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CostMultiply'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->CostMultiply);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: CostMultiply of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_CostMultiply
static int tolua_set_BaseUniqueItem_CostMultiply(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CostMultiply'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->CostMultiply = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: CostAdd of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_CostAdd
static int tolua_get_BaseUniqueItem_CostAdd(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CostAdd'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->CostAdd);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: CostAdd of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_CostAdd
static int tolua_set_BaseUniqueItem_CostAdd(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CostAdd'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->CostAdd = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: CharTransform of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_CharTransform
static int tolua_get_BaseUniqueItem_CharTransform(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CharTransform'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->CharTransform);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: CharTransform of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_CharTransform
static int tolua_set_BaseUniqueItem_CharTransform(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CharTransform'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->CharTransform = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: InvTransform of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_InvTransform
static int tolua_get_BaseUniqueItem_InvTransform(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvTransform'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->InvTransform);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: InvTransform of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_InvTransform
static int tolua_set_BaseUniqueItem_InvTransform(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvTransform'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->InvTransform = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FlippyFile of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_FlippyFile
static int tolua_get_BaseUniqueItem_FlippyFile(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FlippyFile'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FlippyFile);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FlippyFile of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_FlippyFile
static int tolua_set_BaseUniqueItem_FlippyFile(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FlippyFile'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FlippyFile = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: InvFile of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_InvFile
static int tolua_get_BaseUniqueItem_InvFile(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvFile'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->InvFile);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: InvFile of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_InvFile
static int tolua_set_BaseUniqueItem_InvFile(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvFile'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->InvFile = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DropSound of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_DropSound
static int tolua_get_BaseUniqueItem_DropSound(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DropSound'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->DropSound);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DropSound of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_DropSound
static int tolua_set_BaseUniqueItem_DropSound(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DropSound'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DropSound = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DropSfxFrame of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_DropSfxFrame
static int tolua_get_BaseUniqueItem_DropSfxFrame(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DropSfxFrame'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->DropSfxFrame);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DropSfxFrame of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_DropSfxFrame
static int tolua_set_BaseUniqueItem_DropSfxFrame(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DropSfxFrame'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DropSfxFrame = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: UseSound of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_UseSound
static int tolua_get_BaseUniqueItem_UseSound(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'UseSound'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->UseSound);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: UseSound of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_UseSound
static int tolua_set_BaseUniqueItem_UseSound(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'UseSound'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->UseSound = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property1 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Property1_ptr
static int tolua_get_BaseUniqueItem_Property1_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property1'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property1,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property1 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Property1_ptr
static int tolua_set_BaseUniqueItem_Property1_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property1'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property1 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param1 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Param1
static int tolua_get_BaseUniqueItem_Param1(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param1 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Param1
static int tolua_set_BaseUniqueItem_Param1(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min1 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Min1
static int tolua_get_BaseUniqueItem_Min1(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min1 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Min1
static int tolua_set_BaseUniqueItem_Min1(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max1 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Max1
static int tolua_get_BaseUniqueItem_Max1(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max1 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Max1
static int tolua_set_BaseUniqueItem_Max1(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property2 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Property2_ptr
static int tolua_get_BaseUniqueItem_Property2_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property2'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property2,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property2 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Property2_ptr
static int tolua_set_BaseUniqueItem_Property2_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property2'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property2 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param2 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Param2
static int tolua_get_BaseUniqueItem_Param2(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param2 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Param2
static int tolua_set_BaseUniqueItem_Param2(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min2 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Min2
static int tolua_get_BaseUniqueItem_Min2(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min2 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Min2
static int tolua_set_BaseUniqueItem_Min2(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max2 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Max2
static int tolua_get_BaseUniqueItem_Max2(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max2 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Max2
static int tolua_set_BaseUniqueItem_Max2(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property3 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Property3_ptr
static int tolua_get_BaseUniqueItem_Property3_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property3'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property3,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property3 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Property3_ptr
static int tolua_set_BaseUniqueItem_Property3_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property3'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property3 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param3 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Param3
static int tolua_get_BaseUniqueItem_Param3(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param3 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Param3
static int tolua_set_BaseUniqueItem_Param3(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param3 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min3 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Min3
static int tolua_get_BaseUniqueItem_Min3(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min3 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Min3
static int tolua_set_BaseUniqueItem_Min3(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min3 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max3 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Max3
static int tolua_get_BaseUniqueItem_Max3(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max3 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Max3
static int tolua_set_BaseUniqueItem_Max3(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max3 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property4 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Property4_ptr
static int tolua_get_BaseUniqueItem_Property4_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property4'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property4,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property4 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Property4_ptr
static int tolua_set_BaseUniqueItem_Property4_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property4'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property4 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param4 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Param4
static int tolua_get_BaseUniqueItem_Param4(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param4'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param4 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Param4
static int tolua_set_BaseUniqueItem_Param4(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param4'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param4 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min4 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Min4
static int tolua_get_BaseUniqueItem_Min4(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min4'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min4 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Min4
static int tolua_set_BaseUniqueItem_Min4(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min4'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min4 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max4 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Max4
static int tolua_get_BaseUniqueItem_Max4(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max4'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max4 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Max4
static int tolua_set_BaseUniqueItem_Max4(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max4'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max4 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property5 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Property5_ptr
static int tolua_get_BaseUniqueItem_Property5_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property5'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property5,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property5 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Property5_ptr
static int tolua_set_BaseUniqueItem_Property5_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property5'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property5 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param5 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Param5
static int tolua_get_BaseUniqueItem_Param5(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param5'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param5 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Param5
static int tolua_set_BaseUniqueItem_Param5(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param5'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param5 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min5 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Min5
static int tolua_get_BaseUniqueItem_Min5(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min5'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min5 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Min5
static int tolua_set_BaseUniqueItem_Min5(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min5'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min5 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max5 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Max5
static int tolua_get_BaseUniqueItem_Max5(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max5'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max5 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Max5
static int tolua_set_BaseUniqueItem_Max5(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max5'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max5 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property6 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Property6_ptr
static int tolua_get_BaseUniqueItem_Property6_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property6'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property6,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property6 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Property6_ptr
static int tolua_set_BaseUniqueItem_Property6_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property6'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property6 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param6 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Param6
static int tolua_get_BaseUniqueItem_Param6(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param6'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param6 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Param6
static int tolua_set_BaseUniqueItem_Param6(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param6'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param6 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min6 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Min6
static int tolua_get_BaseUniqueItem_Min6(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min6'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min6 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Min6
static int tolua_set_BaseUniqueItem_Min6(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min6'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min6 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max6 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Max6
static int tolua_get_BaseUniqueItem_Max6(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max6'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max6 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Max6
static int tolua_set_BaseUniqueItem_Max6(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max6'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max6 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property7 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Property7_ptr
static int tolua_get_BaseUniqueItem_Property7_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property7'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property7,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property7 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Property7_ptr
static int tolua_set_BaseUniqueItem_Property7_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property7'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property7 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param7 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Param7
static int tolua_get_BaseUniqueItem_Param7(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param7'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param7 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Param7
static int tolua_set_BaseUniqueItem_Param7(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param7'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param7 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min7 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Min7
static int tolua_get_BaseUniqueItem_Min7(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min7'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min7 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Min7
static int tolua_set_BaseUniqueItem_Min7(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min7'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min7 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max7 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Max7
static int tolua_get_BaseUniqueItem_Max7(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max7'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max7 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Max7
static int tolua_set_BaseUniqueItem_Max7(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max7'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max7 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property8 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Property8_ptr
static int tolua_get_BaseUniqueItem_Property8_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property8'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property8,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property8 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Property8_ptr
static int tolua_set_BaseUniqueItem_Property8_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property8'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property8 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param8 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Param8
static int tolua_get_BaseUniqueItem_Param8(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param8'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param8);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param8 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Param8
static int tolua_set_BaseUniqueItem_Param8(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param8'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param8 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min8 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Min8
static int tolua_get_BaseUniqueItem_Min8(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min8'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min8);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min8 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Min8
static int tolua_set_BaseUniqueItem_Min8(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min8'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min8 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max8 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Max8
static int tolua_get_BaseUniqueItem_Max8(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max8'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max8);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max8 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Max8
static int tolua_set_BaseUniqueItem_Max8(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max8'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max8 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property9 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Property9_ptr
static int tolua_get_BaseUniqueItem_Property9_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property9'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property9,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property9 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Property9_ptr
static int tolua_set_BaseUniqueItem_Property9_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property9'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property9 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param9 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Param9
static int tolua_get_BaseUniqueItem_Param9(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param9'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param9);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param9 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Param9
static int tolua_set_BaseUniqueItem_Param9(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param9'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param9 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min9 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Min9
static int tolua_get_BaseUniqueItem_Min9(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min9'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min9);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min9 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Min9
static int tolua_set_BaseUniqueItem_Min9(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min9'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min9 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max9 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Max9
static int tolua_get_BaseUniqueItem_Max9(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max9'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max9);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max9 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Max9
static int tolua_set_BaseUniqueItem_Max9(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max9'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max9 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property10 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Property10_ptr
static int tolua_get_BaseUniqueItem_Property10_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property10'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property10,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property10 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Property10_ptr
static int tolua_set_BaseUniqueItem_Property10_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property10'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property10 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param10 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Param10
static int tolua_get_BaseUniqueItem_Param10(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param10'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param10);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param10 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Param10
static int tolua_set_BaseUniqueItem_Param10(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param10'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param10 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min10 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Min10
static int tolua_get_BaseUniqueItem_Min10(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min10'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min10);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min10 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Min10
static int tolua_set_BaseUniqueItem_Min10(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min10'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min10 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max10 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Max10
static int tolua_get_BaseUniqueItem_Max10(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max10'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max10);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max10 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Max10
static int tolua_set_BaseUniqueItem_Max10(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max10'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max10 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property11 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Property11_ptr
static int tolua_get_BaseUniqueItem_Property11_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property11'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property11,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property11 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Property11_ptr
static int tolua_set_BaseUniqueItem_Property11_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property11'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property11 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param11 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Param11
static int tolua_get_BaseUniqueItem_Param11(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param11'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param11);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param11 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Param11
static int tolua_set_BaseUniqueItem_Param11(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param11'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param11 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min11 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Min11
static int tolua_get_BaseUniqueItem_Min11(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min11'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min11);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min11 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Min11
static int tolua_set_BaseUniqueItem_Min11(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min11'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min11 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max11 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Max11
static int tolua_get_BaseUniqueItem_Max11(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max11'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max11);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max11 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Max11
static int tolua_set_BaseUniqueItem_Max11(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max11'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max11 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property12 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Property12_ptr
static int tolua_get_BaseUniqueItem_Property12_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property12'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property12,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property12 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Property12_ptr
static int tolua_set_BaseUniqueItem_Property12_ptr(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property12'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property12 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param12 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Param12
static int tolua_get_BaseUniqueItem_Param12(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param12'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param12);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param12 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Param12
static int tolua_set_BaseUniqueItem_Param12(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param12'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param12 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min12 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Min12
static int tolua_get_BaseUniqueItem_Min12(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min12'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min12);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min12 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Min12
static int tolua_set_BaseUniqueItem_Min12(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min12'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min12 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max12 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseUniqueItem_Max12
static int tolua_get_BaseUniqueItem_Max12(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max12'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max12);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max12 of class  BaseUniqueItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseUniqueItem_Max12
static int tolua_set_BaseUniqueItem_Max12(lua_State* tolua_S)
{
  BaseUniqueItem* self = (BaseUniqueItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max12'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max12 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Index of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_Index
static int tolua_get_ItemSet_Index(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Index);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Index of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_Index
static int tolua_set_ItemSet_Index(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Index = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Id of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_Id
static int tolua_get_ItemSet_Id(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Id'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Id);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Id of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_Id
static int tolua_set_ItemSet_Id(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Id'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Id = ((ItemSetType::ItemSetType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Name of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_Name
static int tolua_get_ItemSet_Name(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Name);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Name of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_Name
static int tolua_set_ItemSet_Name(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Name = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Name2 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_Name2
static int tolua_get_ItemSet_Name2(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name2'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Name2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Name2 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_Name2
static int tolua_set_ItemSet_Name2(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name2'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Name2 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Version of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_Version
static int tolua_get_ItemSet_Version(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Version'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Version);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Version of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_Version
static int tolua_set_ItemSet_Version(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Version'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Version = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Level of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_Level
static int tolua_get_ItemSet_Level(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Level'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Level);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Level of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_Level
static int tolua_set_ItemSet_Level(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Level'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Level = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PCode2a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PCode2a
static int tolua_get_ItemSet_PCode2a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode2a'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PCode2a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PCode2a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PCode2a
static int tolua_set_ItemSet_PCode2a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode2a'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PCode2a = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PParam2a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PParam2a
static int tolua_get_ItemSet_PParam2a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam2a'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PParam2a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PParam2a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PParam2a
static int tolua_set_ItemSet_PParam2a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam2a'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PParam2a = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMin2a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMin2a
static int tolua_get_ItemSet_PMin2a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin2a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMin2a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMin2a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMin2a
static int tolua_set_ItemSet_PMin2a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin2a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMin2a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMax2a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMax2a
static int tolua_get_ItemSet_PMax2a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax2a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMax2a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMax2a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMax2a
static int tolua_set_ItemSet_PMax2a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax2a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMax2a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PCode2b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PCode2b
static int tolua_get_ItemSet_PCode2b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode2b'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PCode2b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PCode2b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PCode2b
static int tolua_set_ItemSet_PCode2b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode2b'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PCode2b = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PParam2b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PParam2b
static int tolua_get_ItemSet_PParam2b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam2b'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PParam2b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PParam2b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PParam2b
static int tolua_set_ItemSet_PParam2b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam2b'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PParam2b = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMin2b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMin2b
static int tolua_get_ItemSet_PMin2b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin2b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMin2b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMin2b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMin2b
static int tolua_set_ItemSet_PMin2b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin2b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMin2b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMax2b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMax2b
static int tolua_get_ItemSet_PMax2b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax2b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMax2b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMax2b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMax2b
static int tolua_set_ItemSet_PMax2b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax2b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMax2b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PCode3a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PCode3a
static int tolua_get_ItemSet_PCode3a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode3a'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PCode3a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PCode3a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PCode3a
static int tolua_set_ItemSet_PCode3a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode3a'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PCode3a = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PParam3a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PParam3a
static int tolua_get_ItemSet_PParam3a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam3a'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PParam3a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PParam3a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PParam3a
static int tolua_set_ItemSet_PParam3a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam3a'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PParam3a = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMin3a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMin3a
static int tolua_get_ItemSet_PMin3a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin3a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMin3a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMin3a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMin3a
static int tolua_set_ItemSet_PMin3a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin3a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMin3a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMax3a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMax3a
static int tolua_get_ItemSet_PMax3a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax3a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMax3a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMax3a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMax3a
static int tolua_set_ItemSet_PMax3a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax3a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMax3a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PCode3b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PCode3b
static int tolua_get_ItemSet_PCode3b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode3b'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PCode3b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PCode3b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PCode3b
static int tolua_set_ItemSet_PCode3b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode3b'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PCode3b = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PParam3b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PParam3b
static int tolua_get_ItemSet_PParam3b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam3b'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PParam3b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PParam3b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PParam3b
static int tolua_set_ItemSet_PParam3b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam3b'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PParam3b = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMin3b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMin3b
static int tolua_get_ItemSet_PMin3b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin3b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMin3b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMin3b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMin3b
static int tolua_set_ItemSet_PMin3b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin3b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMin3b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMax3b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMax3b
static int tolua_get_ItemSet_PMax3b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax3b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMax3b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMax3b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMax3b
static int tolua_set_ItemSet_PMax3b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax3b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMax3b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PCode4a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PCode4a
static int tolua_get_ItemSet_PCode4a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode4a'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PCode4a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PCode4a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PCode4a
static int tolua_set_ItemSet_PCode4a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode4a'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PCode4a = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PParam4a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PParam4a
static int tolua_get_ItemSet_PParam4a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam4a'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PParam4a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PParam4a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PParam4a
static int tolua_set_ItemSet_PParam4a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam4a'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PParam4a = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMin4a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMin4a
static int tolua_get_ItemSet_PMin4a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin4a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMin4a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMin4a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMin4a
static int tolua_set_ItemSet_PMin4a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin4a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMin4a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMax4a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMax4a
static int tolua_get_ItemSet_PMax4a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax4a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMax4a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMax4a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMax4a
static int tolua_set_ItemSet_PMax4a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax4a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMax4a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PCode4b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PCode4b
static int tolua_get_ItemSet_PCode4b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode4b'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PCode4b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PCode4b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PCode4b
static int tolua_set_ItemSet_PCode4b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode4b'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PCode4b = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PParam4b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PParam4b
static int tolua_get_ItemSet_PParam4b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam4b'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PParam4b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PParam4b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PParam4b
static int tolua_set_ItemSet_PParam4b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam4b'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PParam4b = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMin4b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMin4b
static int tolua_get_ItemSet_PMin4b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin4b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMin4b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMin4b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMin4b
static int tolua_set_ItemSet_PMin4b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin4b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMin4b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMax4b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMax4b
static int tolua_get_ItemSet_PMax4b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax4b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMax4b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMax4b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMax4b
static int tolua_set_ItemSet_PMax4b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax4b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMax4b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PCode5a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PCode5a
static int tolua_get_ItemSet_PCode5a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode5a'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PCode5a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PCode5a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PCode5a
static int tolua_set_ItemSet_PCode5a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode5a'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PCode5a = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PParam5a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PParam5a
static int tolua_get_ItemSet_PParam5a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam5a'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PParam5a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PParam5a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PParam5a
static int tolua_set_ItemSet_PParam5a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam5a'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PParam5a = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMin5a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMin5a
static int tolua_get_ItemSet_PMin5a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin5a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMin5a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMin5a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMin5a
static int tolua_set_ItemSet_PMin5a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin5a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMin5a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMax5a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMax5a
static int tolua_get_ItemSet_PMax5a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax5a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMax5a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMax5a of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMax5a
static int tolua_set_ItemSet_PMax5a(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax5a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMax5a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PCode5b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PCode5b
static int tolua_get_ItemSet_PCode5b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode5b'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PCode5b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PCode5b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PCode5b
static int tolua_set_ItemSet_PCode5b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PCode5b'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PCode5b = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PParam5b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PParam5b
static int tolua_get_ItemSet_PParam5b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam5b'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->PParam5b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PParam5b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PParam5b
static int tolua_set_ItemSet_PParam5b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PParam5b'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PParam5b = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMin5b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMin5b
static int tolua_get_ItemSet_PMin5b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin5b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMin5b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMin5b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMin5b
static int tolua_set_ItemSet_PMin5b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMin5b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMin5b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PMax5b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_PMax5b
static int tolua_get_ItemSet_PMax5b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax5b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->PMax5b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PMax5b of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_PMax5b
static int tolua_set_ItemSet_PMax5b(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'PMax5b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->PMax5b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FCode1 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FCode1
static int tolua_get_ItemSet_FCode1(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode1'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FCode1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FCode1 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FCode1
static int tolua_set_ItemSet_FCode1(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode1'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FCode1 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FParam1 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FParam1
static int tolua_get_ItemSet_FParam1(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam1'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FParam1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FParam1 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FParam1
static int tolua_set_ItemSet_FParam1(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam1'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FParam1 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMin1 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMin1
static int tolua_get_ItemSet_FMin1(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMin1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMin1 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMin1
static int tolua_set_ItemSet_FMin1(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMin1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMax1 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMax1
static int tolua_get_ItemSet_FMax1(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMax1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMax1 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMax1
static int tolua_set_ItemSet_FMax1(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMax1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FCode2 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FCode2
static int tolua_get_ItemSet_FCode2(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode2'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FCode2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FCode2 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FCode2
static int tolua_set_ItemSet_FCode2(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode2'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FCode2 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FParam2 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FParam2
static int tolua_get_ItemSet_FParam2(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam2'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FParam2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FParam2 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FParam2
static int tolua_set_ItemSet_FParam2(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam2'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FParam2 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMin2 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMin2
static int tolua_get_ItemSet_FMin2(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMin2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMin2 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMin2
static int tolua_set_ItemSet_FMin2(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMin2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMax2 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMax2
static int tolua_get_ItemSet_FMax2(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMax2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMax2 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMax2
static int tolua_set_ItemSet_FMax2(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMax2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FCode3 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FCode3
static int tolua_get_ItemSet_FCode3(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode3'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FCode3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FCode3 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FCode3
static int tolua_set_ItemSet_FCode3(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode3'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FCode3 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FParam3 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FParam3
static int tolua_get_ItemSet_FParam3(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam3'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FParam3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FParam3 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FParam3
static int tolua_set_ItemSet_FParam3(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam3'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FParam3 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMin3 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMin3
static int tolua_get_ItemSet_FMin3(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMin3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMin3 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMin3
static int tolua_set_ItemSet_FMin3(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMin3 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMax3 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMax3
static int tolua_get_ItemSet_FMax3(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMax3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMax3 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMax3
static int tolua_set_ItemSet_FMax3(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMax3 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FCode4 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FCode4
static int tolua_get_ItemSet_FCode4(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode4'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FCode4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FCode4 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FCode4
static int tolua_set_ItemSet_FCode4(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode4'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FCode4 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FParam4 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FParam4
static int tolua_get_ItemSet_FParam4(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam4'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FParam4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FParam4 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FParam4
static int tolua_set_ItemSet_FParam4(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam4'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FParam4 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMin4 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMin4
static int tolua_get_ItemSet_FMin4(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin4'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMin4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMin4 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMin4
static int tolua_set_ItemSet_FMin4(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin4'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMin4 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMax4 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMax4
static int tolua_get_ItemSet_FMax4(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax4'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMax4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMax4 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMax4
static int tolua_set_ItemSet_FMax4(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax4'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMax4 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FCode5 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FCode5
static int tolua_get_ItemSet_FCode5(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode5'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FCode5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FCode5 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FCode5
static int tolua_set_ItemSet_FCode5(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode5'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FCode5 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FParam5 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FParam5
static int tolua_get_ItemSet_FParam5(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam5'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FParam5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FParam5 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FParam5
static int tolua_set_ItemSet_FParam5(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam5'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FParam5 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMin5 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMin5
static int tolua_get_ItemSet_FMin5(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin5'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMin5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMin5 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMin5
static int tolua_set_ItemSet_FMin5(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin5'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMin5 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMax5 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMax5
static int tolua_get_ItemSet_FMax5(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax5'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMax5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMax5 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMax5
static int tolua_set_ItemSet_FMax5(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax5'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMax5 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FCode6 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FCode6
static int tolua_get_ItemSet_FCode6(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode6'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FCode6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FCode6 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FCode6
static int tolua_set_ItemSet_FCode6(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode6'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FCode6 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FParam6 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FParam6
static int tolua_get_ItemSet_FParam6(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam6'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FParam6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FParam6 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FParam6
static int tolua_set_ItemSet_FParam6(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam6'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FParam6 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMin6 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMin6
static int tolua_get_ItemSet_FMin6(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin6'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMin6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMin6 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMin6
static int tolua_set_ItemSet_FMin6(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin6'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMin6 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMax6 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMax6
static int tolua_get_ItemSet_FMax6(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax6'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMax6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMax6 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMax6
static int tolua_set_ItemSet_FMax6(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax6'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMax6 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FCode7 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FCode7
static int tolua_get_ItemSet_FCode7(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode7'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FCode7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FCode7 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FCode7
static int tolua_set_ItemSet_FCode7(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode7'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FCode7 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FParam7 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FParam7
static int tolua_get_ItemSet_FParam7(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam7'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FParam7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FParam7 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FParam7
static int tolua_set_ItemSet_FParam7(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam7'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FParam7 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMin7 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMin7
static int tolua_get_ItemSet_FMin7(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin7'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMin7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMin7 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMin7
static int tolua_set_ItemSet_FMin7(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin7'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMin7 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMax7 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMax7
static int tolua_get_ItemSet_FMax7(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax7'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMax7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMax7 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMax7
static int tolua_set_ItemSet_FMax7(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax7'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMax7 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FCode8 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FCode8
static int tolua_get_ItemSet_FCode8(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode8'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FCode8);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FCode8 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FCode8
static int tolua_set_ItemSet_FCode8(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FCode8'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FCode8 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FParam8 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FParam8
static int tolua_get_ItemSet_FParam8(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam8'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FParam8);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FParam8 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FParam8
static int tolua_set_ItemSet_FParam8(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FParam8'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FParam8 = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMin8 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMin8
static int tolua_get_ItemSet_FMin8(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin8'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMin8);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMin8 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMin8
static int tolua_set_ItemSet_FMin8(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMin8'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMin8 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FMax8 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_get_ItemSet_FMax8
static int tolua_get_ItemSet_FMax8(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax8'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FMax8);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FMax8 of class  ItemSet */
#ifndef TOLUA_DISABLE_tolua_set_ItemSet_FMax8
static int tolua_set_ItemSet_FMax8(lua_State* tolua_S)
{
  ItemSet* self = (ItemSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FMax8'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FMax8 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Index of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Index
static int tolua_get_BaseSetItem_Index(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Index);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Index of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Index
static int tolua_set_BaseSetItem_Index(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Index'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Index = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Id of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Id
static int tolua_get_BaseSetItem_Id(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Id'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->Id,"SetItemType::SetItemType");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Id of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Id
static int tolua_set_BaseSetItem_Id(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Id'",NULL);
  if (!tolua_isusertype(tolua_S,2,"SetItemType::SetItemType",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Id = *((SetItemType::SetItemType*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Name of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Name
static int tolua_get_BaseSetItem_Name(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Name);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Name of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Name
static int tolua_set_BaseSetItem_Name(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Name = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Set of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Set_ptr
static int tolua_get_BaseSetItem_Set_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Set,"ItemSet");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Set of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Set_ptr
static int tolua_set_BaseSetItem_Set_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Set'",NULL);
  if (!tolua_isusertype(tolua_S,2,"ItemSet",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Set = ((ItemSet*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Item of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Item_ptr
static int tolua_get_BaseSetItem_Item_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Item'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Item,"BaseItem");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Item of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Item_ptr
static int tolua_set_BaseSetItem_Item_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Item'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseItem",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Item = ((BaseItem*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Rarity of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Rarity
static int tolua_get_BaseSetItem_Rarity(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rarity'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Rarity);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Rarity of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Rarity
static int tolua_set_BaseSetItem_Rarity(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Rarity'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Rarity = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DropLevel of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_DropLevel
static int tolua_get_BaseSetItem_DropLevel(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DropLevel'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->DropLevel);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DropLevel of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_DropLevel
static int tolua_set_BaseSetItem_DropLevel(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DropLevel'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DropLevel = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: RequiredLevel of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_RequiredLevel
static int tolua_get_BaseSetItem_RequiredLevel(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'RequiredLevel'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->RequiredLevel);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: RequiredLevel of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_RequiredLevel
static int tolua_set_BaseSetItem_RequiredLevel(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'RequiredLevel'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->RequiredLevel = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: CharTransform of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_CharTransform
static int tolua_get_BaseSetItem_CharTransform(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CharTransform'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->CharTransform);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: CharTransform of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_CharTransform
static int tolua_set_BaseSetItem_CharTransform(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CharTransform'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->CharTransform = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: InvTransform of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_InvTransform
static int tolua_get_BaseSetItem_InvTransform(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvTransform'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->InvTransform);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: InvTransform of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_InvTransform
static int tolua_set_BaseSetItem_InvTransform(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvTransform'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->InvTransform = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: InvFile of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_InvFile
static int tolua_get_BaseSetItem_InvFile(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvFile'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->InvFile);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: InvFile of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_InvFile
static int tolua_set_BaseSetItem_InvFile(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'InvFile'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->InvFile = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FlippyFile of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_FlippyFile
static int tolua_get_BaseSetItem_FlippyFile(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FlippyFile'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->FlippyFile);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FlippyFile of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_FlippyFile
static int tolua_set_BaseSetItem_FlippyFile(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FlippyFile'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FlippyFile = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DropSound of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_DropSound
static int tolua_get_BaseSetItem_DropSound(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DropSound'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->DropSound);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DropSound of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_DropSound
static int tolua_set_BaseSetItem_DropSound(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DropSound'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DropSound = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DropSfxFrame of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_DropSfxFrame
static int tolua_get_BaseSetItem_DropSfxFrame(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DropSfxFrame'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->DropSfxFrame);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DropSfxFrame of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_DropSfxFrame
static int tolua_set_BaseSetItem_DropSfxFrame(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DropSfxFrame'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DropSfxFrame = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: UseSound of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_UseSound
static int tolua_get_BaseSetItem_UseSound(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'UseSound'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->UseSound);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: UseSound of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_UseSound
static int tolua_set_BaseSetItem_UseSound(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'UseSound'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->UseSound = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: CostMultiply of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_CostMultiply
static int tolua_get_BaseSetItem_CostMultiply(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CostMultiply'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->CostMultiply);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: CostMultiply of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_CostMultiply
static int tolua_set_BaseSetItem_CostMultiply(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CostMultiply'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->CostMultiply = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: CostAdd of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_CostAdd
static int tolua_get_BaseSetItem_CostAdd(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CostAdd'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->CostAdd);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: CostAdd of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_CostAdd
static int tolua_set_BaseSetItem_CostAdd(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'CostAdd'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->CostAdd = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AddFunc of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AddFunc
static int tolua_get_BaseSetItem_AddFunc(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AddFunc'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AddFunc);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AddFunc of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AddFunc
static int tolua_set_BaseSetItem_AddFunc(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AddFunc'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AddFunc = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property1 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Property1_ptr
static int tolua_get_BaseSetItem_Property1_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property1'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property1,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property1 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Property1_ptr
static int tolua_set_BaseSetItem_Property1_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property1'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property1 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param1 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Param1
static int tolua_get_BaseSetItem_Param1(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param1 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Param1
static int tolua_set_BaseSetItem_Param1(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min1 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Min1
static int tolua_get_BaseSetItem_Min1(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min1 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Min1
static int tolua_set_BaseSetItem_Min1(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max1 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Max1
static int tolua_get_BaseSetItem_Max1(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max1 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Max1
static int tolua_set_BaseSetItem_Max1(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property2 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Property2_ptr
static int tolua_get_BaseSetItem_Property2_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property2'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property2,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property2 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Property2_ptr
static int tolua_set_BaseSetItem_Property2_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property2'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property2 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param2 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Param2
static int tolua_get_BaseSetItem_Param2(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param2 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Param2
static int tolua_set_BaseSetItem_Param2(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min2 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Min2
static int tolua_get_BaseSetItem_Min2(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min2 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Min2
static int tolua_set_BaseSetItem_Min2(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max2 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Max2
static int tolua_get_BaseSetItem_Max2(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max2'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max2);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max2 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Max2
static int tolua_set_BaseSetItem_Max2(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max2'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max2 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property3 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Property3_ptr
static int tolua_get_BaseSetItem_Property3_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property3'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property3,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property3 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Property3_ptr
static int tolua_set_BaseSetItem_Property3_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property3'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property3 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param3 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Param3
static int tolua_get_BaseSetItem_Param3(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param3 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Param3
static int tolua_set_BaseSetItem_Param3(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param3 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min3 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Min3
static int tolua_get_BaseSetItem_Min3(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min3 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Min3
static int tolua_set_BaseSetItem_Min3(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min3 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max3 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Max3
static int tolua_get_BaseSetItem_Max3(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max3'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max3);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max3 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Max3
static int tolua_set_BaseSetItem_Max3(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max3'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max3 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property4 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Property4_ptr
static int tolua_get_BaseSetItem_Property4_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property4'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property4,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property4 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Property4_ptr
static int tolua_set_BaseSetItem_Property4_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property4'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property4 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param4 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Param4
static int tolua_get_BaseSetItem_Param4(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param4'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param4 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Param4
static int tolua_set_BaseSetItem_Param4(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param4'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param4 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min4 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Min4
static int tolua_get_BaseSetItem_Min4(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min4'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min4 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Min4
static int tolua_set_BaseSetItem_Min4(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min4'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min4 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max4 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Max4
static int tolua_get_BaseSetItem_Max4(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max4'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max4);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max4 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Max4
static int tolua_set_BaseSetItem_Max4(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max4'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max4 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property5 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Property5_ptr
static int tolua_get_BaseSetItem_Property5_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property5'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property5,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property5 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Property5_ptr
static int tolua_set_BaseSetItem_Property5_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property5'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property5 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param5 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Param5
static int tolua_get_BaseSetItem_Param5(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param5'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param5 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Param5
static int tolua_set_BaseSetItem_Param5(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param5'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param5 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min5 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Min5
static int tolua_get_BaseSetItem_Min5(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min5'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min5 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Min5
static int tolua_set_BaseSetItem_Min5(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min5'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min5 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max5 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Max5
static int tolua_get_BaseSetItem_Max5(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max5'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max5);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max5 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Max5
static int tolua_set_BaseSetItem_Max5(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max5'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max5 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property6 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Property6_ptr
static int tolua_get_BaseSetItem_Property6_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property6'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property6,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property6 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Property6_ptr
static int tolua_set_BaseSetItem_Property6_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property6'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property6 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param6 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Param6
static int tolua_get_BaseSetItem_Param6(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param6'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param6 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Param6
static int tolua_set_BaseSetItem_Param6(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param6'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param6 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min6 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Min6
static int tolua_get_BaseSetItem_Min6(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min6'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min6 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Min6
static int tolua_set_BaseSetItem_Min6(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min6'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min6 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max6 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Max6
static int tolua_get_BaseSetItem_Max6(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max6'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max6);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max6 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Max6
static int tolua_set_BaseSetItem_Max6(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max6'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max6 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property7 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Property7_ptr
static int tolua_get_BaseSetItem_Property7_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property7'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property7,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property7 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Property7_ptr
static int tolua_set_BaseSetItem_Property7_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property7'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property7 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param7 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Param7
static int tolua_get_BaseSetItem_Param7(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param7'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param7 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Param7
static int tolua_set_BaseSetItem_Param7(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param7'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param7 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min7 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Min7
static int tolua_get_BaseSetItem_Min7(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min7'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min7 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Min7
static int tolua_set_BaseSetItem_Min7(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min7'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min7 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max7 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Max7
static int tolua_get_BaseSetItem_Max7(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max7'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max7);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max7 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Max7
static int tolua_set_BaseSetItem_Max7(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max7'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max7 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property8 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Property8_ptr
static int tolua_get_BaseSetItem_Property8_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property8'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property8,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property8 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Property8_ptr
static int tolua_set_BaseSetItem_Property8_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property8'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property8 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param8 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Param8
static int tolua_get_BaseSetItem_Param8(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param8'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param8);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param8 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Param8
static int tolua_set_BaseSetItem_Param8(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param8'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param8 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min8 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Min8
static int tolua_get_BaseSetItem_Min8(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min8'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min8);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min8 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Min8
static int tolua_set_BaseSetItem_Min8(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min8'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min8 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max8 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Max8
static int tolua_get_BaseSetItem_Max8(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max8'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max8);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max8 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Max8
static int tolua_set_BaseSetItem_Max8(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max8'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max8 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Property9 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Property9_ptr
static int tolua_get_BaseSetItem_Property9_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property9'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->Property9,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Property9 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Property9_ptr
static int tolua_set_BaseSetItem_Property9_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Property9'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Property9 = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Param9 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Param9
static int tolua_get_BaseSetItem_Param9(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param9'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Param9);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Param9 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Param9
static int tolua_set_BaseSetItem_Param9(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Param9'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Param9 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Min9 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Min9
static int tolua_get_BaseSetItem_Min9(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min9'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Min9);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Min9 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Min9
static int tolua_set_BaseSetItem_Min9(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Min9'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Min9 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Max9 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_Max9
static int tolua_get_BaseSetItem_Max9(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max9'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->Max9);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Max9 of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_Max9
static int tolua_set_BaseSetItem_Max9(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Max9'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Max9 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AProperty1a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AProperty1a_ptr
static int tolua_get_BaseSetItem_AProperty1a_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty1a'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->AProperty1a,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AProperty1a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AProperty1a_ptr
static int tolua_set_BaseSetItem_AProperty1a_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty1a'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AProperty1a = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AParam1a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AParam1a
static int tolua_get_BaseSetItem_AParam1a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam1a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AParam1a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AParam1a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AParam1a
static int tolua_set_BaseSetItem_AParam1a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam1a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AParam1a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMin1a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMin1a
static int tolua_get_BaseSetItem_AMin1a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin1a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMin1a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMin1a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMin1a
static int tolua_set_BaseSetItem_AMin1a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin1a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMin1a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMax1a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMax1a
static int tolua_get_BaseSetItem_AMax1a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax1a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMax1a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMax1a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMax1a
static int tolua_set_BaseSetItem_AMax1a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax1a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMax1a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AProperty1b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AProperty1b_ptr
static int tolua_get_BaseSetItem_AProperty1b_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty1b'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->AProperty1b,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AProperty1b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AProperty1b_ptr
static int tolua_set_BaseSetItem_AProperty1b_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty1b'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AProperty1b = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AParam1b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AParam1b
static int tolua_get_BaseSetItem_AParam1b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam1b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AParam1b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AParam1b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AParam1b
static int tolua_set_BaseSetItem_AParam1b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam1b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AParam1b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMin1b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMin1b
static int tolua_get_BaseSetItem_AMin1b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin1b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMin1b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMin1b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMin1b
static int tolua_set_BaseSetItem_AMin1b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin1b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMin1b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMax1b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMax1b
static int tolua_get_BaseSetItem_AMax1b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax1b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMax1b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMax1b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMax1b
static int tolua_set_BaseSetItem_AMax1b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax1b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMax1b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AProperty2a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AProperty2a_ptr
static int tolua_get_BaseSetItem_AProperty2a_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty2a'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->AProperty2a,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AProperty2a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AProperty2a_ptr
static int tolua_set_BaseSetItem_AProperty2a_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty2a'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AProperty2a = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AParam2a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AParam2a
static int tolua_get_BaseSetItem_AParam2a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam2a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AParam2a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AParam2a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AParam2a
static int tolua_set_BaseSetItem_AParam2a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam2a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AParam2a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMin2a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMin2a
static int tolua_get_BaseSetItem_AMin2a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin2a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMin2a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMin2a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMin2a
static int tolua_set_BaseSetItem_AMin2a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin2a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMin2a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMax2a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMax2a
static int tolua_get_BaseSetItem_AMax2a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax2a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMax2a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMax2a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMax2a
static int tolua_set_BaseSetItem_AMax2a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax2a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMax2a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AProperty2b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AProperty2b_ptr
static int tolua_get_BaseSetItem_AProperty2b_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty2b'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->AProperty2b,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AProperty2b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AProperty2b_ptr
static int tolua_set_BaseSetItem_AProperty2b_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty2b'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AProperty2b = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AParam2b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AParam2b
static int tolua_get_BaseSetItem_AParam2b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam2b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AParam2b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AParam2b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AParam2b
static int tolua_set_BaseSetItem_AParam2b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam2b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AParam2b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMin2b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMin2b
static int tolua_get_BaseSetItem_AMin2b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin2b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMin2b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMin2b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMin2b
static int tolua_set_BaseSetItem_AMin2b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin2b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMin2b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMax2b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMax2b
static int tolua_get_BaseSetItem_AMax2b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax2b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMax2b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMax2b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMax2b
static int tolua_set_BaseSetItem_AMax2b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax2b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMax2b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AProperty3a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AProperty3a_ptr
static int tolua_get_BaseSetItem_AProperty3a_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty3a'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->AProperty3a,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AProperty3a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AProperty3a_ptr
static int tolua_set_BaseSetItem_AProperty3a_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty3a'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AProperty3a = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AParam3a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AParam3a
static int tolua_get_BaseSetItem_AParam3a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam3a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AParam3a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AParam3a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AParam3a
static int tolua_set_BaseSetItem_AParam3a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam3a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AParam3a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMin3a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMin3a
static int tolua_get_BaseSetItem_AMin3a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin3a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMin3a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMin3a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMin3a
static int tolua_set_BaseSetItem_AMin3a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin3a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMin3a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMax3a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMax3a
static int tolua_get_BaseSetItem_AMax3a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax3a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMax3a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMax3a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMax3a
static int tolua_set_BaseSetItem_AMax3a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax3a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMax3a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AProperty3b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AProperty3b_ptr
static int tolua_get_BaseSetItem_AProperty3b_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty3b'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->AProperty3b,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AProperty3b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AProperty3b_ptr
static int tolua_set_BaseSetItem_AProperty3b_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty3b'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AProperty3b = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AParam3b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AParam3b
static int tolua_get_BaseSetItem_AParam3b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam3b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AParam3b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AParam3b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AParam3b
static int tolua_set_BaseSetItem_AParam3b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam3b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AParam3b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMin3b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMin3b
static int tolua_get_BaseSetItem_AMin3b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin3b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMin3b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMin3b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMin3b
static int tolua_set_BaseSetItem_AMin3b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin3b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMin3b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMax3b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMax3b
static int tolua_get_BaseSetItem_AMax3b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax3b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMax3b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMax3b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMax3b
static int tolua_set_BaseSetItem_AMax3b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax3b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMax3b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AProperty4a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AProperty4a_ptr
static int tolua_get_BaseSetItem_AProperty4a_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty4a'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->AProperty4a,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AProperty4a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AProperty4a_ptr
static int tolua_set_BaseSetItem_AProperty4a_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty4a'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AProperty4a = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AParam4a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AParam4a
static int tolua_get_BaseSetItem_AParam4a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam4a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AParam4a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AParam4a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AParam4a
static int tolua_set_BaseSetItem_AParam4a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam4a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AParam4a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMin4a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMin4a
static int tolua_get_BaseSetItem_AMin4a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin4a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMin4a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMin4a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMin4a
static int tolua_set_BaseSetItem_AMin4a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin4a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMin4a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMax4a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMax4a
static int tolua_get_BaseSetItem_AMax4a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax4a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMax4a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMax4a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMax4a
static int tolua_set_BaseSetItem_AMax4a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax4a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMax4a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AProperty4b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AProperty4b_ptr
static int tolua_get_BaseSetItem_AProperty4b_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty4b'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->AProperty4b,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AProperty4b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AProperty4b_ptr
static int tolua_set_BaseSetItem_AProperty4b_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty4b'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AProperty4b = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AParam4b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AParam4b
static int tolua_get_BaseSetItem_AParam4b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam4b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AParam4b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AParam4b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AParam4b
static int tolua_set_BaseSetItem_AParam4b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam4b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AParam4b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMin4b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMin4b
static int tolua_get_BaseSetItem_AMin4b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin4b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMin4b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMin4b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMin4b
static int tolua_set_BaseSetItem_AMin4b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin4b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMin4b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMax4b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMax4b
static int tolua_get_BaseSetItem_AMax4b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax4b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMax4b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMax4b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMax4b
static int tolua_set_BaseSetItem_AMax4b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax4b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMax4b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AProperty5a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AProperty5a_ptr
static int tolua_get_BaseSetItem_AProperty5a_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty5a'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->AProperty5a,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AProperty5a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AProperty5a_ptr
static int tolua_set_BaseSetItem_AProperty5a_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty5a'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AProperty5a = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AParam5a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AParam5a
static int tolua_get_BaseSetItem_AParam5a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam5a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AParam5a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AParam5a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AParam5a
static int tolua_set_BaseSetItem_AParam5a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam5a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AParam5a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMin5a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMin5a
static int tolua_get_BaseSetItem_AMin5a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin5a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMin5a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMin5a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMin5a
static int tolua_set_BaseSetItem_AMin5a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin5a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMin5a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMax5a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMax5a
static int tolua_get_BaseSetItem_AMax5a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax5a'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMax5a);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMax5a of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMax5a
static int tolua_set_BaseSetItem_AMax5a(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax5a'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMax5a = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AProperty5b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AProperty5b_ptr
static int tolua_get_BaseSetItem_AProperty5b_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty5b'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->AProperty5b,"BaseProperty");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AProperty5b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AProperty5b_ptr
static int tolua_set_BaseSetItem_AProperty5b_ptr(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AProperty5b'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseProperty",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AProperty5b = ((BaseProperty*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AParam5b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AParam5b
static int tolua_get_BaseSetItem_AParam5b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam5b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AParam5b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AParam5b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AParam5b
static int tolua_set_BaseSetItem_AParam5b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AParam5b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AParam5b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMin5b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMin5b
static int tolua_get_BaseSetItem_AMin5b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin5b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMin5b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMin5b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMin5b
static int tolua_set_BaseSetItem_AMin5b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMin5b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMin5b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: AMax5b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_get_BaseSetItem_AMax5b
static int tolua_get_BaseSetItem_AMax5b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax5b'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->AMax5b);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: AMax5b of class  BaseSetItem */
#ifndef TOLUA_DISABLE_tolua_set_BaseSetItem_AMax5b
static int tolua_set_BaseSetItem_AMax5b(lua_State* tolua_S)
{
  BaseSetItem* self = (BaseSetItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'AMax5b'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->AMax5b = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  std::vector<MagicPrefixType::MagicPrefixType> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_MagicPrefixType__MagicPrefixType__clear00
static int tolua_item_std_vector_MagicPrefixType__MagicPrefixType__clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<MagicPrefixType::MagicPrefixType>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<MagicPrefixType::MagicPrefixType>* self = (std::vector<MagicPrefixType::MagicPrefixType>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'",NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  std::vector<MagicPrefixType::MagicPrefixType> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_MagicPrefixType__MagicPrefixType__size00
static int tolua_item_std_vector_MagicPrefixType__MagicPrefixType__size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<MagicPrefixType::MagicPrefixType>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<MagicPrefixType::MagicPrefixType>* self = (const std::vector<MagicPrefixType::MagicPrefixType>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'",NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<MagicPrefixType::MagicPrefixType> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_MagicPrefixType__MagicPrefixType___geti00
static int tolua_item_std_vector_MagicPrefixType__MagicPrefixType___geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<MagicPrefixType::MagicPrefixType>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<MagicPrefixType::MagicPrefixType>* self = (const std::vector<MagicPrefixType::MagicPrefixType>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'",NULL);
#endif
  {
   const MagicPrefixType::MagicPrefixType tolua_ret = (const MagicPrefixType::MagicPrefixType)  self->operator[](index);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  std::vector<MagicPrefixType::MagicPrefixType> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_MagicPrefixType__MagicPrefixType___seti00
static int tolua_item_std_vector_MagicPrefixType__MagicPrefixType___seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<MagicPrefixType::MagicPrefixType>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<MagicPrefixType::MagicPrefixType>* self = (std::vector<MagicPrefixType::MagicPrefixType>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
  MagicPrefixType::MagicPrefixType tolua_value = ((MagicPrefixType::MagicPrefixType) (int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'",NULL);
#endif
  self->operator[](index) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<MagicPrefixType::MagicPrefixType> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_MagicPrefixType__MagicPrefixType___geti01
static int tolua_item_std_vector_MagicPrefixType__MagicPrefixType___geti01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<MagicPrefixType::MagicPrefixType>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  std::vector<MagicPrefixType::MagicPrefixType>* self = (std::vector<MagicPrefixType::MagicPrefixType>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'",NULL);
#endif
  {
   MagicPrefixType::MagicPrefixType tolua_ret = (MagicPrefixType::MagicPrefixType)  self->operator[](index);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_item_std_vector_MagicPrefixType__MagicPrefixType___geti00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  std::vector<MagicPrefixType::MagicPrefixType> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_MagicPrefixType__MagicPrefixType__push_back00
static int tolua_item_std_vector_MagicPrefixType__MagicPrefixType__push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<MagicPrefixType::MagicPrefixType>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<MagicPrefixType::MagicPrefixType>* self = (std::vector<MagicPrefixType::MagicPrefixType>*)  tolua_tousertype(tolua_S,1,0);
  MagicPrefixType::MagicPrefixType val = ((MagicPrefixType::MagicPrefixType) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'",NULL);
#endif
  {
   self->push_back(val);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<MagicPrefixType::MagicPrefixType> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_MagicPrefixType__MagicPrefixType__new00
static int tolua_item_std_vector_MagicPrefixType__MagicPrefixType__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<MagicPrefixType::MagicPrefixType>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<MagicPrefixType::MagicPrefixType>* tolua_ret = (std::vector<MagicPrefixType::MagicPrefixType>*)  new std::vector<MagicPrefixType::MagicPrefixType>();
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<MagicPrefixType::MagicPrefixType>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<MagicPrefixType::MagicPrefixType> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_MagicPrefixType__MagicPrefixType__new00_local
static int tolua_item_std_vector_MagicPrefixType__MagicPrefixType__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<MagicPrefixType::MagicPrefixType>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<MagicPrefixType::MagicPrefixType>* tolua_ret = (std::vector<MagicPrefixType::MagicPrefixType>*)  new std::vector<MagicPrefixType::MagicPrefixType>();
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"std::vector<MagicPrefixType::MagicPrefixType>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  std::vector<MagicPrefixType::MagicPrefixType> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_MagicPrefixType__MagicPrefixType__delete00
static int tolua_item_std_vector_MagicPrefixType__MagicPrefixType__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<MagicPrefixType::MagicPrefixType>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<MagicPrefixType::MagicPrefixType>* self = (std::vector<MagicPrefixType::MagicPrefixType>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
  delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  std::vector<StatBase> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_StatBase__clear00
static int tolua_item_std_vector_StatBase__clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<StatBase>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<StatBase>* self = (std::vector<StatBase>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'",NULL);
#endif
  {
   self->clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  std::vector<StatBase> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_StatBase__size00
static int tolua_item_std_vector_StatBase__size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<StatBase>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<StatBase>* self = (const std::vector<StatBase>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'",NULL);
#endif
  {
   int tolua_ret = (int)  self->size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<StatBase> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_StatBase___geti00
static int tolua_item_std_vector_StatBase___geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::vector<StatBase>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::vector<StatBase>* self = (const std::vector<StatBase>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'",NULL);
#endif
  {
   const StatBase tolua_ret = (const StatBase)  self->operator[](index);
   {
#ifdef __cplusplus
    void* tolua_obj = new StatBase(tolua_ret);
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"const StatBase");
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const StatBase));
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"const StatBase");
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  std::vector<StatBase> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_StatBase___seti00
static int tolua_item_std_vector_StatBase___seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<StatBase>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"StatBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<StatBase>* self = (std::vector<StatBase>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
  StatBase tolua_value = *((StatBase*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'",NULL);
#endif
  self->operator[](index) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  std::vector<StatBase> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_StatBase___geti01
static int tolua_item_std_vector_StatBase___geti01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<StatBase>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  std::vector<StatBase>* self = (std::vector<StatBase>*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'",NULL);
#endif
  {
   StatBase tolua_ret = (StatBase)  self->operator[](index);
   {
#ifdef __cplusplus
    void* tolua_obj = new StatBase(tolua_ret);
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"StatBase");
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(StatBase));
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"StatBase");
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_item_std_vector_StatBase___geti00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  std::vector<StatBase> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_StatBase__push_back00
static int tolua_item_std_vector_StatBase__push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<StatBase>",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"StatBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<StatBase>* self = (std::vector<StatBase>*)  tolua_tousertype(tolua_S,1,0);
  StatBase val = *((StatBase*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'",NULL);
#endif
  {
   self->push_back(val);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  std::vector<StatBase> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_StatBase__new00
static int tolua_item_std_vector_StatBase__new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<StatBase>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<StatBase>* tolua_ret = (std::vector<StatBase>*)  new std::vector<StatBase>();
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<StatBase>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::vector<StatBase> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_StatBase__new00_local
static int tolua_item_std_vector_StatBase__new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::vector<StatBase>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::vector<StatBase>* tolua_ret = (std::vector<StatBase>*)  new std::vector<StatBase>();
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"std::vector<StatBase>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  std::vector<StatBase> */
#ifndef TOLUA_DISABLE_tolua_item_std_vector_StatBase__delete00
static int tolua_item_std_vector_StatBase__delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::vector<StatBase>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::vector<StatBase>* self = (std::vector<StatBase>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
  delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: action of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_action
static int tolua_get_Item_action(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'action'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->action);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: action of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_action
static int tolua_set_Item_action(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'action'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->action = ((ItemActionType::ItemActionType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: category of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_category
static int tolua_get_Item_category(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'category'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->category);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: category of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_category
static int tolua_set_Item_category(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'category'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->category = ((ItemCategory::ItemCategory) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: uid of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_unsigned_uid
static int tolua_get_Item_unsigned_uid(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'uid'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->uid);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: uid of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_unsigned_uid
static int tolua_set_Item_unsigned_uid(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'uid'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->uid = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: flags of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_flags
static int tolua_get_Item_flags(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'flags'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->flags);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: flags of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_flags
static int tolua_set_Item_flags(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'flags'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->flags = ((ItemFlags::ItemFlags) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: version of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_version
static int tolua_get_Item_version(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'version'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->version);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: version of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_version
static int tolua_set_Item_version(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'version'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->version = ((ItemVersion::ItemVersion) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: destination of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_destination
static int tolua_get_Item_destination(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'destination'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->destination);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: destination of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_destination
static int tolua_set_Item_destination(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'destination'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->destination = ((ItemDestination::ItemDestination) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: location of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_location
static int tolua_get_Item_location(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'location'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->location);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: location of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_location
static int tolua_set_Item_location(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'location'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->location = ((EquipmentLocation::EquipmentLocation) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: x of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_x
static int tolua_get_Item_x(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->x);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: x of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_x
static int tolua_set_Item_x(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->x = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: y of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_y
static int tolua_get_Item_y(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->y);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: y of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_y
static int tolua_set_Item_y(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->y = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: container of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_container
static int tolua_get_Item_container(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'container'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->container);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: container of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_container
static int tolua_set_Item_container(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'container'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->container = ((ItemContainer::ItemContainer) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: baseItem of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_baseItem_ptr
static int tolua_get_Item_baseItem_ptr(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'baseItem'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->baseItem,"BaseItem");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: baseItem of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_baseItem_ptr
static int tolua_set_Item_baseItem_ptr(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'baseItem'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseItem",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->baseItem = ((BaseItem*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: setItem of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_setItem_ptr
static int tolua_get_Item_setItem_ptr(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'setItem'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->setItem,"BaseSetItem");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: setItem of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_setItem_ptr
static int tolua_set_Item_setItem_ptr(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'setItem'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseSetItem",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->setItem = ((BaseSetItem*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: uniqueItem of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_uniqueItem_ptr
static int tolua_get_Item_uniqueItem_ptr(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'uniqueItem'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->uniqueItem,"BaseUniqueItem");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: uniqueItem of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_uniqueItem_ptr
static int tolua_set_Item_uniqueItem_ptr(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'uniqueItem'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseUniqueItem",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->uniqueItem = ((BaseUniqueItem*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: runeword of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_runeword_ptr
static int tolua_get_Item_runeword_ptr(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'runeword'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)self->runeword,"BaseRuneword");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: runeword of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_runeword_ptr
static int tolua_set_Item_runeword_ptr(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'runeword'",NULL);
  if (!tolua_isusertype(tolua_S,2,"BaseRuneword",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->runeword = ((BaseRuneword*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: quality of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_quality
static int tolua_get_Item_quality(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'quality'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->quality);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: quality of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_quality
static int tolua_set_Item_quality(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'quality'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->quality = ((ItemQuality::ItemQuality) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: superiorType of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_superiorType
static int tolua_get_Item_superiorType(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'superiorType'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->superiorType);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: superiorType of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_superiorType
static int tolua_set_Item_superiorType(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'superiorType'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->superiorType = ((SuperiorItemType::SuperiorItemType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: prefix of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_prefix
static int tolua_get_Item_prefix(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'prefix'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->prefix,"ItemAffix");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: prefix of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_prefix
static int tolua_set_Item_prefix(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'prefix'",NULL);
  if (!tolua_isusertype(tolua_S,2,"ItemAffix",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->prefix = *((ItemAffix*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: suffix of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_suffix
static int tolua_get_Item_suffix(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'suffix'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->suffix,"ItemAffix");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: suffix of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_suffix
static int tolua_set_Item_suffix(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'suffix'",NULL);
  if (!tolua_isusertype(tolua_S,2,"ItemAffix",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->suffix = *((ItemAffix*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: magicPrefixes of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_magicPrefixes
static int tolua_get_Item_magicPrefixes(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'magicPrefixes'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->magicPrefixes,"std::vector<MagicPrefixType::MagicPrefixType>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: magicPrefixes of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_magicPrefixes
static int tolua_set_Item_magicPrefixes(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'magicPrefixes'",NULL);
  if (!tolua_isusertype(tolua_S,2,"std::vector<MagicPrefixType::MagicPrefixType>",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->magicPrefixes = *((std::vector<MagicPrefixType::MagicPrefixType>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: magicSuffixes of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_magicSuffixes
static int tolua_get_Item_magicSuffixes(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'magicSuffixes'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->magicSuffixes,"std::vector<MagicSuffixType::MagicSuffixType>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: magicSuffixes of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_magicSuffixes
static int tolua_set_Item_magicSuffixes(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'magicSuffixes'",NULL);
  if (!tolua_isusertype(tolua_S,2,"std::vector<MagicSuffixType::MagicSuffixType>",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->magicSuffixes = *((std::vector<MagicSuffixType::MagicSuffixType>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: name of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_name
static int tolua_get_Item_name(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->name);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: name of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_name
static int tolua_set_Item_name(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->name = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: charClass of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_charClass
static int tolua_get_Item_charClass(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'charClass'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->charClass,"CharacterClass::CharacterClass");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: charClass of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_charClass
static int tolua_set_Item_charClass(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'charClass'",NULL);
  if (!tolua_isusertype(tolua_S,2,"CharacterClass::CharacterClass",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->charClass = *((CharacterClass::CharacterClass*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: level of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_level
static int tolua_get_Item_level(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'level'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->level);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: level of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_level
static int tolua_set_Item_level(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'level'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->level = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: usedSockets of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_usedSockets
static int tolua_get_Item_usedSockets(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'usedSockets'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->usedSockets);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: usedSockets of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_usedSockets
static int tolua_set_Item_usedSockets(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'usedSockets'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->usedSockets = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: use of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_use
static int tolua_get_Item_use(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'use'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->use);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: use of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_use
static int tolua_set_Item_use(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'use'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->use = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: graphic of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_graphic
static int tolua_get_Item_graphic(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'graphic'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->graphic);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: graphic of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_graphic
static int tolua_set_Item_graphic(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'graphic'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->graphic = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: color of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_color
static int tolua_get_Item_color(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'color'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->color);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: color of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_color
static int tolua_set_Item_color(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'color'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->color = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: stats of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_stats
static int tolua_get_Item_stats(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stats'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->stats,"std::vector<StatBase>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: stats of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_stats
static int tolua_set_Item_stats(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'stats'",NULL);
  if (!tolua_isusertype(tolua_S,2,"std::vector<StatBase>",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->stats = *((std::vector<StatBase>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: mods of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_mods
static int tolua_get_Item_mods(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'mods'",NULL);
#endif
  tolua_pushusertype(tolua_S,(void*)&self->mods,"std::vector<StatBase>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: mods of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_mods
static int tolua_set_Item_mods(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'mods'",NULL);
  if (!tolua_isusertype(tolua_S,2,"std::vector<StatBase>",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->mods = *((std::vector<StatBase>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: unknown1 of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_unknown1
static int tolua_get_Item_unknown1(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'unknown1'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->unknown1);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: unknown1 of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_unknown1
static int tolua_set_Item_unknown1(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'unknown1'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->unknown1 = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: runewordID of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_runewordID
static int tolua_get_Item_runewordID(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'runewordID'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->runewordID);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: runewordID of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_runewordID
static int tolua_set_Item_runewordID(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'runewordID'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->runewordID = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: runewordParam of class  Item */
#ifndef TOLUA_DISABLE_tolua_get_Item_runewordParam
static int tolua_get_Item_runewordParam(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'runewordParam'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->runewordParam);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: runewordParam of class  Item */
#ifndef TOLUA_DISABLE_tolua_set_Item_runewordParam
static int tolua_set_Item_runewordParam(lua_State* tolua_S)
{
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'runewordParam'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->runewordParam = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Item */
#ifndef TOLUA_DISABLE_tolua_item_Item_new00
static int tolua_item_Item_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Item",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Item* tolua_ret = (Item*)  new Item();
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Item");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Item */
#ifndef TOLUA_DISABLE_tolua_item_Item_new00_local
static int tolua_item_Item_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Item",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Item* tolua_ret = (Item*)  new Item();
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Item");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  Item */
#ifndef TOLUA_DISABLE_tolua_item_Item_delete00
static int tolua_item_Item_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Item",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Item* self = (Item*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
  delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_item_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  tolua_module(tolua_S,"ItemEventType",0);
  tolua_beginmodule(tolua_S,"ItemEventType");
   tolua_constant(tolua_S,"None",ItemEventType::None);
   tolua_constant(tolua_S,"DoMeleeAttack",ItemEventType::DoMeleeAttack);
   tolua_constant(tolua_S,"DoMissileAttack",ItemEventType::DoMissileAttack);
   tolua_constant(tolua_S,"DoMeleeDamage",ItemEventType::DoMeleeDamage);
   tolua_constant(tolua_S,"DoMissileDamage",ItemEventType::DoMissileDamage);
   tolua_constant(tolua_S,"Kill",ItemEventType::Kill);
   tolua_constant(tolua_S,"DamagedInMelee",ItemEventType::DamagedInMelee);
   tolua_constant(tolua_S,"DamagedByMissile",ItemEventType::DamagedByMissile);
   tolua_constant(tolua_S,"Death",ItemEventType::Death);
   tolua_constant(tolua_S,"LevelUp",ItemEventType::LevelUp);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"StorePage",0);
  tolua_beginmodule(tolua_S,"StorePage");
   tolua_constant(tolua_S,"NotApplicable",StorePage::NotApplicable);
   tolua_constant(tolua_S,"None",StorePage::None);
   tolua_constant(tolua_S,"Armor",StorePage::Armor);
   tolua_constant(tolua_S,"Weapon",StorePage::Weapon);
   tolua_constant(tolua_S,"Misc",StorePage::Misc);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"ItemVersion",0);
  tolua_beginmodule(tolua_S,"ItemVersion");
   tolua_constant(tolua_S,"Classic",ItemVersion::Classic);
   tolua_constant(tolua_S,"Classic110",ItemVersion::Classic110);
   tolua_constant(tolua_S,"LoD",ItemVersion::LoD);
   tolua_constant(tolua_S,"LoD110",ItemVersion::LoD110);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"ItemClass",0);
  tolua_beginmodule(tolua_S,"ItemClass");
   tolua_constant(tolua_S,"NotApplicable",ItemClass::NotApplicable);
   tolua_constant(tolua_S,"Normal",ItemClass::Normal);
   tolua_constant(tolua_S,"Exceptional",ItemClass::Exceptional);
   tolua_constant(tolua_S,"Elite",ItemClass::Elite);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"ItemQuality",0);
  tolua_beginmodule(tolua_S,"ItemQuality");
   tolua_constant(tolua_S,"NotApplicable",ItemQuality::NotApplicable);
   tolua_constant(tolua_S,"Inferior",ItemQuality::Inferior);
   tolua_constant(tolua_S,"Normal",ItemQuality::Normal);
   tolua_constant(tolua_S,"Superior",ItemQuality::Superior);
   tolua_constant(tolua_S,"Magic",ItemQuality::Magic);
   tolua_constant(tolua_S,"Set",ItemQuality::Set);
   tolua_constant(tolua_S,"Rare",ItemQuality::Rare);
   tolua_constant(tolua_S,"Unique",ItemQuality::Unique);
   tolua_constant(tolua_S,"Crafted",ItemQuality::Crafted);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EquipmentLocation",0);
  tolua_beginmodule(tolua_S,"EquipmentLocation");
   tolua_constant(tolua_S,"NotApplicable",EquipmentLocation::NotApplicable);
   tolua_constant(tolua_S,"Helm",EquipmentLocation::Helm);
   tolua_constant(tolua_S,"Amulet",EquipmentLocation::Amulet);
   tolua_constant(tolua_S,"Armor",EquipmentLocation::Armor);
   tolua_constant(tolua_S,"RightHand",EquipmentLocation::RightHand);
   tolua_constant(tolua_S,"LeftHand",EquipmentLocation::LeftHand);
   tolua_constant(tolua_S,"RightHandRing",EquipmentLocation::RightHandRing);
   tolua_constant(tolua_S,"LeftHandRing",EquipmentLocation::LeftHandRing);
   tolua_constant(tolua_S,"Belt",EquipmentLocation::Belt);
   tolua_constant(tolua_S,"Boots",EquipmentLocation::Boots);
   tolua_constant(tolua_S,"Gloves",EquipmentLocation::Gloves);
   tolua_constant(tolua_S,"RightHandSwitch",EquipmentLocation::RightHandSwitch);
   tolua_constant(tolua_S,"LeftHandSwitch",EquipmentLocation::LeftHandSwitch);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"ItemCategory",0);
  tolua_beginmodule(tolua_S,"ItemCategory");
   tolua_constant(tolua_S,"Helm",ItemCategory::Helm);
   tolua_constant(tolua_S,"Armor",ItemCategory::Armor);
   tolua_constant(tolua_S,"Weapon",ItemCategory::Weapon);
   tolua_constant(tolua_S,"Weapon2",ItemCategory::Weapon2);
   tolua_constant(tolua_S,"Shield",ItemCategory::Shield);
   tolua_constant(tolua_S,"Special",ItemCategory::Special);
   tolua_constant(tolua_S,"Misc",ItemCategory::Misc);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"ItemContainer",0);
  tolua_beginmodule(tolua_S,"ItemContainer");
   tolua_constant(tolua_S,"Unspecified",ItemContainer::Unspecified);
   tolua_constant(tolua_S,"Inventory",ItemContainer::Inventory);
   tolua_constant(tolua_S,"TraderOffer",ItemContainer::TraderOffer);
   tolua_constant(tolua_S,"ForTrade",ItemContainer::ForTrade);
   tolua_constant(tolua_S,"Cube",ItemContainer::Cube);
   tolua_constant(tolua_S,"Stash",ItemContainer::Stash);
   tolua_constant(tolua_S,"Belt",ItemContainer::Belt);
   tolua_constant(tolua_S,"Item",ItemContainer::Item);
   tolua_constant(tolua_S,"ArmorTab",ItemContainer::ArmorTab);
   tolua_constant(tolua_S,"WeaponTab1",ItemContainer::WeaponTab1);
   tolua_constant(tolua_S,"WeaponTab2",ItemContainer::WeaponTab2);
   tolua_constant(tolua_S,"MiscTab",ItemContainer::MiscTab);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"ItemDestination",0);
  tolua_beginmodule(tolua_S,"ItemDestination");
   tolua_constant(tolua_S,"Unspecified",ItemDestination::Unspecified);
   tolua_constant(tolua_S,"Equipment",ItemDestination::Equipment);
   tolua_constant(tolua_S,"Belt",ItemDestination::Belt);
   tolua_constant(tolua_S,"Ground",ItemDestination::Ground);
   tolua_constant(tolua_S,"Cursor",ItemDestination::Cursor);
   tolua_constant(tolua_S,"Item",ItemDestination::Item);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"ItemActionType",0);
  tolua_beginmodule(tolua_S,"ItemActionType");
   tolua_constant(tolua_S,"AddToGround",ItemActionType::AddToGround);
   tolua_constant(tolua_S,"GroundToCursor",ItemActionType::GroundToCursor);
   tolua_constant(tolua_S,"DropToGround",ItemActionType::DropToGround);
   tolua_constant(tolua_S,"OnGround",ItemActionType::OnGround);
   tolua_constant(tolua_S,"PutInContainer",ItemActionType::PutInContainer);
   tolua_constant(tolua_S,"RemoveFromContainer",ItemActionType::RemoveFromContainer);
   tolua_constant(tolua_S,"Equip",ItemActionType::Equip);
   tolua_constant(tolua_S,"IndirectlySwapBodyItem",ItemActionType::IndirectlySwapBodyItem);
   tolua_constant(tolua_S,"Unequip",ItemActionType::Unequip);
   tolua_constant(tolua_S,"SwapBodyItem",ItemActionType::SwapBodyItem);
   tolua_constant(tolua_S,"AddQuantity",ItemActionType::AddQuantity);
   tolua_constant(tolua_S,"AddToShop",ItemActionType::AddToShop);
   tolua_constant(tolua_S,"RemoveFromShop",ItemActionType::RemoveFromShop);
   tolua_constant(tolua_S,"SwapInContainer",ItemActionType::SwapInContainer);
   tolua_constant(tolua_S,"PutInBelt",ItemActionType::PutInBelt);
   tolua_constant(tolua_S,"RemoveFromBelt",ItemActionType::RemoveFromBelt);
   tolua_constant(tolua_S,"SwapInBelt",ItemActionType::SwapInBelt);
   tolua_constant(tolua_S,"AutoUnequip",ItemActionType::AutoUnequip);
   tolua_constant(tolua_S,"ToCursor",ItemActionType::ToCursor);
   tolua_constant(tolua_S,"ItemInSocket",ItemActionType::ItemInSocket);
   tolua_constant(tolua_S,"UNKNOWNx14",ItemActionType::UNKNOWNx14);
   tolua_constant(tolua_S,"UpdateStats",ItemActionType::UpdateStats);
   tolua_constant(tolua_S,"UNKNOWNx16",ItemActionType::UNKNOWNx16);
   tolua_constant(tolua_S,"WeaponSwitch",ItemActionType::WeaponSwitch);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"ItemFlags",0);
  tolua_beginmodule(tolua_S,"ItemFlags");
   tolua_constant(tolua_S,"None",ItemFlags::None);
   tolua_constant(tolua_S,"Equipped",ItemFlags::Equipped);
   tolua_constant(tolua_S,"InSocket",ItemFlags::InSocket);
   tolua_constant(tolua_S,"Identified",ItemFlags::Identified);
   tolua_constant(tolua_S,"x20",ItemFlags::x20);
   tolua_constant(tolua_S,"SwitchedIn",ItemFlags::SwitchedIn);
   tolua_constant(tolua_S,"SwitchedOut",ItemFlags::SwitchedOut);
   tolua_constant(tolua_S,"Broken",ItemFlags::Broken);
   tolua_constant(tolua_S,"Duplicate",ItemFlags::Duplicate);
   tolua_constant(tolua_S,"Socketed",ItemFlags::Socketed);
   tolua_constant(tolua_S,"OnPet",ItemFlags::OnPet);
   tolua_constant(tolua_S,"x2000",ItemFlags::x2000);
   tolua_constant(tolua_S,"NotInSocket",ItemFlags::NotInSocket);
   tolua_constant(tolua_S,"Ear",ItemFlags::Ear);
   tolua_constant(tolua_S,"StartItem",ItemFlags::StartItem);
   tolua_constant(tolua_S,"Compact",ItemFlags::Compact);
   tolua_constant(tolua_S,"Ethereal",ItemFlags::Ethereal);
   tolua_constant(tolua_S,"Any",ItemFlags::Any);
   tolua_constant(tolua_S,"Personalized",ItemFlags::Personalized);
   tolua_constant(tolua_S,"Gamble",ItemFlags::Gamble);
   tolua_constant(tolua_S,"Runeword",ItemFlags::Runeword);
   tolua_constant(tolua_S,"x8000000",ItemFlags::x8000000);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"SuperiorItemType",0);
  tolua_beginmodule(tolua_S,"SuperiorItemType");
   tolua_constant(tolua_S,"NotApplicable",SuperiorItemType::NotApplicable);
   tolua_constant(tolua_S,"AttackRating",SuperiorItemType::AttackRating);
   tolua_constant(tolua_S,"Damage",SuperiorItemType::Damage);
   tolua_constant(tolua_S,"Defense",SuperiorItemType::Defense);
   tolua_constant(tolua_S,"DamageAttackRating",SuperiorItemType::DamageAttackRating);
   tolua_constant(tolua_S,"Durability",SuperiorItemType::Durability);
   tolua_constant(tolua_S,"AttackRatingDurability",SuperiorItemType::AttackRatingDurability);
   tolua_constant(tolua_S,"DamageDurability",SuperiorItemType::DamageDurability);
   tolua_constant(tolua_S,"DefenseDurability",SuperiorItemType::DefenseDurability);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"BaseItemType","BaseItemType","",NULL);
  tolua_beginmodule(tolua_S,"BaseItemType");
   tolua_variable(tolua_S,"Index",tolua_get_BaseItemType_Index,tolua_set_BaseItemType_Index);
   tolua_variable(tolua_S,"Type",tolua_get_BaseItemType_Type,tolua_set_BaseItemType_Type);
   tolua_variable(tolua_S,"Name",tolua_get_BaseItemType_Name,tolua_set_BaseItemType_Name);
   tolua_variable(tolua_S,"Code",tolua_get_BaseItemType_Code,tolua_set_BaseItemType_Code);
   tolua_variable(tolua_S,"Equiv1",tolua_get_BaseItemType_Equiv1,tolua_set_BaseItemType_Equiv1);
   tolua_variable(tolua_S,"Equiv2",tolua_get_BaseItemType_Equiv2,tolua_set_BaseItemType_Equiv2);
   tolua_variable(tolua_S,"Repair",tolua_get_BaseItemType_Repair,tolua_set_BaseItemType_Repair);
   tolua_variable(tolua_S,"Body",tolua_get_BaseItemType_Body,tolua_set_BaseItemType_Body);
   tolua_variable(tolua_S,"BodyLoc1",tolua_get_BaseItemType_BodyLoc1,tolua_set_BaseItemType_BodyLoc1);
   tolua_variable(tolua_S,"BodyLoc2",tolua_get_BaseItemType_BodyLoc2,tolua_set_BaseItemType_BodyLoc2);
   tolua_variable(tolua_S,"Shoots",tolua_get_BaseItemType_Shoots,tolua_set_BaseItemType_Shoots);
   tolua_variable(tolua_S,"Quiver",tolua_get_BaseItemType_Quiver,tolua_set_BaseItemType_Quiver);
   tolua_variable(tolua_S,"Throwable",tolua_get_BaseItemType_Throwable,tolua_set_BaseItemType_Throwable);
   tolua_variable(tolua_S,"Reload",tolua_get_BaseItemType_Reload,tolua_set_BaseItemType_Reload);
   tolua_variable(tolua_S,"ReEquip",tolua_get_BaseItemType_ReEquip,tolua_set_BaseItemType_ReEquip);
   tolua_variable(tolua_S,"AutoStack",tolua_get_BaseItemType_AutoStack,tolua_set_BaseItemType_AutoStack);
   tolua_variable(tolua_S,"Magic",tolua_get_BaseItemType_Magic,tolua_set_BaseItemType_Magic);
   tolua_variable(tolua_S,"Rare",tolua_get_BaseItemType_Rare,tolua_set_BaseItemType_Rare);
   tolua_variable(tolua_S,"Normal",tolua_get_BaseItemType_Normal,tolua_set_BaseItemType_Normal);
   tolua_variable(tolua_S,"Charm",tolua_get_BaseItemType_Charm,tolua_set_BaseItemType_Charm);
   tolua_variable(tolua_S,"Gem",tolua_get_BaseItemType_Gem,tolua_set_BaseItemType_Gem);
   tolua_variable(tolua_S,"Beltable",tolua_get_BaseItemType_Beltable,tolua_set_BaseItemType_Beltable);
   tolua_variable(tolua_S,"MaxSock1",tolua_get_BaseItemType_MaxSock1,tolua_set_BaseItemType_MaxSock1);
   tolua_variable(tolua_S,"MaxSock25",tolua_get_BaseItemType_MaxSock25,tolua_set_BaseItemType_MaxSock25);
   tolua_variable(tolua_S,"MaxSock40",tolua_get_BaseItemType_MaxSock40,tolua_set_BaseItemType_MaxSock40);
   tolua_variable(tolua_S,"TreasureClass",tolua_get_BaseItemType_TreasureClass,tolua_set_BaseItemType_TreasureClass);
   tolua_variable(tolua_S,"Rarity",tolua_get_BaseItemType_Rarity,tolua_set_BaseItemType_Rarity);
   tolua_variable(tolua_S,"StaffMods",tolua_get_BaseItemType_StaffMods,tolua_set_BaseItemType_StaffMods);
   tolua_variable(tolua_S,"CostFormula",tolua_get_BaseItemType_CostFormula,tolua_set_BaseItemType_CostFormula);
   tolua_variable(tolua_S,"Class",tolua_get_BaseItemType_Class,tolua_set_BaseItemType_Class);
   tolua_variable(tolua_S,"VarInvGfx",tolua_get_BaseItemType_VarInvGfx,tolua_set_BaseItemType_VarInvGfx);
   tolua_variable(tolua_S,"InvGfx1",tolua_get_BaseItemType_InvGfx1,tolua_set_BaseItemType_InvGfx1);
   tolua_variable(tolua_S,"InvGfx2",tolua_get_BaseItemType_InvGfx2,tolua_set_BaseItemType_InvGfx2);
   tolua_variable(tolua_S,"InvGfx3",tolua_get_BaseItemType_InvGfx3,tolua_set_BaseItemType_InvGfx3);
   tolua_variable(tolua_S,"InvGfx4",tolua_get_BaseItemType_InvGfx4,tolua_set_BaseItemType_InvGfx4);
   tolua_variable(tolua_S,"InvGfx5",tolua_get_BaseItemType_InvGfx5,tolua_set_BaseItemType_InvGfx5);
   tolua_variable(tolua_S,"InvGfx6",tolua_get_BaseItemType_InvGfx6,tolua_set_BaseItemType_InvGfx6);
   tolua_variable(tolua_S,"Page",tolua_get_BaseItemType_Page,tolua_set_BaseItemType_Page);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"BaseItem","BaseItem","",NULL);
  tolua_beginmodule(tolua_S,"BaseItem");
   tolua_variable(tolua_S,"type",tolua_get_BaseItem_type,tolua_set_BaseItem_type);
   tolua_variable(tolua_S,"index",tolua_get_BaseItem_index,tolua_set_BaseItem_index);
   tolua_variable(tolua_S,"tableIndex",tolua_get_BaseItem_tableIndex,tolua_set_BaseItem_tableIndex);
   tolua_variable(tolua_S,"baseType",tolua_get_BaseItem_baseType_ptr,tolua_set_BaseItem_baseType_ptr);
   tolua_variable(tolua_S,"baseType2",tolua_get_BaseItem_baseType2_ptr,tolua_set_BaseItem_baseType2_ptr);
   tolua_variable(tolua_S,"code",tolua_get_BaseItem_code,tolua_set_BaseItem_code);
   tolua_variable(tolua_S,"id",tolua_get_BaseItem_unsigned_id,tolua_set_BaseItem_unsigned_id);
   tolua_variable(tolua_S,"nightmareUpgrade",tolua_get_BaseItem_unsigned_nightmareUpgrade,tolua_set_BaseItem_unsigned_nightmareUpgrade);
   tolua_variable(tolua_S,"hellUpgrade",tolua_get_BaseItem_unsigned_hellUpgrade,tolua_set_BaseItem_unsigned_hellUpgrade);
   tolua_variable(tolua_S,"akaraMagicLvl",tolua_get_BaseItem_akaraMagicLvl,tolua_set_BaseItem_akaraMagicLvl);
   tolua_variable(tolua_S,"akaraMagicMax",tolua_get_BaseItem_akaraMagicMax,tolua_set_BaseItem_akaraMagicMax);
   tolua_variable(tolua_S,"akaraMagicMin",tolua_get_BaseItem_akaraMagicMin,tolua_set_BaseItem_akaraMagicMin);
   tolua_variable(tolua_S,"akaraMax",tolua_get_BaseItem_akaraMax,tolua_set_BaseItem_akaraMax);
   tolua_variable(tolua_S,"akaraMin",tolua_get_BaseItem_akaraMin,tolua_set_BaseItem_akaraMin);
   tolua_variable(tolua_S,"alkorMagicLvl",tolua_get_BaseItem_alkorMagicLvl,tolua_set_BaseItem_alkorMagicLvl);
   tolua_variable(tolua_S,"alkorMagicMax",tolua_get_BaseItem_alkorMagicMax,tolua_set_BaseItem_alkorMagicMax);
   tolua_variable(tolua_S,"alkorMagicMin",tolua_get_BaseItem_alkorMagicMin,tolua_set_BaseItem_alkorMagicMin);
   tolua_variable(tolua_S,"alkorMax",tolua_get_BaseItem_alkorMax,tolua_set_BaseItem_alkorMax);
   tolua_variable(tolua_S,"alkorMin",tolua_get_BaseItem_alkorMin,tolua_set_BaseItem_alkorMin);
   tolua_variable(tolua_S,"alternateGfx",tolua_get_BaseItem_alternateGfx,tolua_set_BaseItem_alternateGfx);
   tolua_variable(tolua_S,"ashearaMagicLvl",tolua_get_BaseItem_ashearaMagicLvl,tolua_set_BaseItem_ashearaMagicLvl);
   tolua_variable(tolua_S,"ashearaMagicMax",tolua_get_BaseItem_ashearaMagicMax,tolua_set_BaseItem_ashearaMagicMax);
   tolua_variable(tolua_S,"ashearaMagicMin",tolua_get_BaseItem_ashearaMagicMin,tolua_set_BaseItem_ashearaMagicMin);
   tolua_variable(tolua_S,"ashearaMax",tolua_get_BaseItem_ashearaMax,tolua_set_BaseItem_ashearaMax);
   tolua_variable(tolua_S,"ashearaMin",tolua_get_BaseItem_ashearaMin,tolua_set_BaseItem_ashearaMin);
   tolua_variable(tolua_S,"autoPrefix",tolua_get_BaseItem_autoPrefix,tolua_set_BaseItem_autoPrefix);
   tolua_variable(tolua_S,"belt",tolua_get_BaseItem_belt,tolua_set_BaseItem_belt);
   tolua_variable(tolua_S,"bitField1",tolua_get_BaseItem_bitField1,tolua_set_BaseItem_bitField1);
   tolua_variable(tolua_S,"cainMagicLvl",tolua_get_BaseItem_cainMagicLvl,tolua_set_BaseItem_cainMagicLvl);
   tolua_variable(tolua_S,"cainMagicMax",tolua_get_BaseItem_cainMagicMax,tolua_set_BaseItem_cainMagicMax);
   tolua_variable(tolua_S,"cainMagicMin",tolua_get_BaseItem_cainMagicMin,tolua_set_BaseItem_cainMagicMin);
   tolua_variable(tolua_S,"cainMax",tolua_get_BaseItem_cainMax,tolua_set_BaseItem_cainMax);
   tolua_variable(tolua_S,"cainMin",tolua_get_BaseItem_cainMin,tolua_set_BaseItem_cainMin);
   tolua_variable(tolua_S,"charsiMagicLvl",tolua_get_BaseItem_charsiMagicLvl,tolua_set_BaseItem_charsiMagicLvl);
   tolua_variable(tolua_S,"charsiMagicMax",tolua_get_BaseItem_charsiMagicMax,tolua_set_BaseItem_charsiMagicMax);
   tolua_variable(tolua_S,"charsiMagicMin",tolua_get_BaseItem_charsiMagicMin,tolua_set_BaseItem_charsiMagicMin);
   tolua_variable(tolua_S,"charsiMax",tolua_get_BaseItem_charsiMax,tolua_set_BaseItem_charsiMax);
   tolua_variable(tolua_S,"charsiMin",tolua_get_BaseItem_charsiMin,tolua_set_BaseItem_charsiMin);
   tolua_variable(tolua_S,"compactSave",tolua_get_BaseItem_compactSave,tolua_set_BaseItem_compactSave);
   tolua_variable(tolua_S,"component",tolua_get_BaseItem_component,tolua_set_BaseItem_component);
   tolua_variable(tolua_S,"cost",tolua_get_BaseItem_cost,tolua_set_BaseItem_cost);
   tolua_variable(tolua_S,"drehyaMagicLvl",tolua_get_BaseItem_drehyaMagicLvl,tolua_set_BaseItem_drehyaMagicLvl);
   tolua_variable(tolua_S,"drehyaMagicMax",tolua_get_BaseItem_drehyaMagicMax,tolua_set_BaseItem_drehyaMagicMax);
   tolua_variable(tolua_S,"drehyaMagicMin",tolua_get_BaseItem_drehyaMagicMin,tolua_set_BaseItem_drehyaMagicMin);
   tolua_variable(tolua_S,"drehyaMax",tolua_get_BaseItem_drehyaMax,tolua_set_BaseItem_drehyaMax);
   tolua_variable(tolua_S,"drehyaMin",tolua_get_BaseItem_drehyaMin,tolua_set_BaseItem_drehyaMin);
   tolua_variable(tolua_S,"drognanMagicLvl",tolua_get_BaseItem_drognanMagicLvl,tolua_set_BaseItem_drognanMagicLvl);
   tolua_variable(tolua_S,"drognanMagicMax",tolua_get_BaseItem_drognanMagicMax,tolua_set_BaseItem_drognanMagicMax);
   tolua_variable(tolua_S,"drognanMagicMin",tolua_get_BaseItem_drognanMagicMin,tolua_set_BaseItem_drognanMagicMin);
   tolua_variable(tolua_S,"drognanMax",tolua_get_BaseItem_drognanMax,tolua_set_BaseItem_drognanMax);
   tolua_variable(tolua_S,"drognanMin",tolua_get_BaseItem_drognanMin,tolua_set_BaseItem_drognanMin);
   tolua_variable(tolua_S,"dropSfxFrame",tolua_get_BaseItem_dropSfxFrame,tolua_set_BaseItem_dropSfxFrame);
   tolua_variable(tolua_S,"dropSound",tolua_get_BaseItem_dropSound,tolua_set_BaseItem_dropSound);
   tolua_variable(tolua_S,"durabilityWarning",tolua_get_BaseItem_durabilityWarning,tolua_set_BaseItem_durabilityWarning);
   tolua_variable(tolua_S,"elzixMagicLvl",tolua_get_BaseItem_elzixMagicLvl,tolua_set_BaseItem_elzixMagicLvl);
   tolua_variable(tolua_S,"elzixMagicMax",tolua_get_BaseItem_elzixMagicMax,tolua_set_BaseItem_elzixMagicMax);
   tolua_variable(tolua_S,"elzixMagicMin",tolua_get_BaseItem_elzixMagicMin,tolua_set_BaseItem_elzixMagicMin);
   tolua_variable(tolua_S,"elzixMax",tolua_get_BaseItem_elzixMax,tolua_set_BaseItem_elzixMax);
   tolua_variable(tolua_S,"elzixMin",tolua_get_BaseItem_elzixMin,tolua_set_BaseItem_elzixMin);
   tolua_variable(tolua_S,"faraMagicLvl",tolua_get_BaseItem_faraMagicLvl,tolua_set_BaseItem_faraMagicLvl);
   tolua_variable(tolua_S,"faraMagicMax",tolua_get_BaseItem_faraMagicMax,tolua_set_BaseItem_faraMagicMax);
   tolua_variable(tolua_S,"faraMagicMin",tolua_get_BaseItem_faraMagicMin,tolua_set_BaseItem_faraMagicMin);
   tolua_variable(tolua_S,"faraMax",tolua_get_BaseItem_faraMax,tolua_set_BaseItem_faraMax);
   tolua_variable(tolua_S,"faraMin",tolua_get_BaseItem_faraMin,tolua_set_BaseItem_faraMin);
   tolua_variable(tolua_S,"flippyFile",tolua_get_BaseItem_flippyFile,tolua_set_BaseItem_flippyFile);
   tolua_variable(tolua_S,"gambleCost",tolua_get_BaseItem_gambleCost,tolua_set_BaseItem_gambleCost);
   tolua_variable(tolua_S,"gameArt",tolua_get_BaseItem_gameArt,tolua_set_BaseItem_gameArt);
   tolua_variable(tolua_S,"gemApplyType",tolua_get_BaseItem_gemApplyType,tolua_set_BaseItem_gemApplyType);
   tolua_variable(tolua_S,"gemOffset",tolua_get_BaseItem_gemOffset,tolua_set_BaseItem_gemOffset);
   tolua_variable(tolua_S,"gemSockets",tolua_get_BaseItem_gemSockets,tolua_set_BaseItem_gemSockets);
   tolua_variable(tolua_S,"gheedMagicLvl",tolua_get_BaseItem_gheedMagicLvl,tolua_set_BaseItem_gheedMagicLvl);
   tolua_variable(tolua_S,"gheedMagicMax",tolua_get_BaseItem_gheedMagicMax,tolua_set_BaseItem_gheedMagicMax);
   tolua_variable(tolua_S,"gheedMagicMin",tolua_get_BaseItem_gheedMagicMin,tolua_set_BaseItem_gheedMagicMin);
   tolua_variable(tolua_S,"gheedMax",tolua_get_BaseItem_gheedMax,tolua_set_BaseItem_gheedMax);
   tolua_variable(tolua_S,"gheedMin",tolua_get_BaseItem_gheedMin,tolua_set_BaseItem_gheedMin);
   tolua_variable(tolua_S,"halbuMagicLvl",tolua_get_BaseItem_halbuMagicLvl,tolua_set_BaseItem_halbuMagicLvl);
   tolua_variable(tolua_S,"halbuMagicMax",tolua_get_BaseItem_halbuMagicMax,tolua_set_BaseItem_halbuMagicMax);
   tolua_variable(tolua_S,"halbuMagicMin",tolua_get_BaseItem_halbuMagicMin,tolua_set_BaseItem_halbuMagicMin);
   tolua_variable(tolua_S,"halbuMax",tolua_get_BaseItem_halbuMax,tolua_set_BaseItem_halbuMax);
   tolua_variable(tolua_S,"halbuMin",tolua_get_BaseItem_halbuMin,tolua_set_BaseItem_halbuMin);
   tolua_variable(tolua_S,"hasInv",tolua_get_BaseItem_hasInv,tolua_set_BaseItem_hasInv);
   tolua_variable(tolua_S,"hraltiMagicLvl",tolua_get_BaseItem_hraltiMagicLvl,tolua_set_BaseItem_hraltiMagicLvl);
   tolua_variable(tolua_S,"hraltiMagicMax",tolua_get_BaseItem_hraltiMagicMax,tolua_set_BaseItem_hraltiMagicMax);
   tolua_variable(tolua_S,"hraltiMagicMin",tolua_get_BaseItem_hraltiMagicMin,tolua_set_BaseItem_hraltiMagicMin);
   tolua_variable(tolua_S,"hraltiMax",tolua_get_BaseItem_hraltiMax,tolua_set_BaseItem_hraltiMax);
   tolua_variable(tolua_S,"hraltiMin",tolua_get_BaseItem_hraltiMin,tolua_set_BaseItem_hraltiMin);
   tolua_variable(tolua_S,"invFile",tolua_get_BaseItem_invFile,tolua_set_BaseItem_invFile);
   tolua_variable(tolua_S,"invHeight",tolua_get_BaseItem_invHeight,tolua_set_BaseItem_invHeight);
   tolua_variable(tolua_S,"invTrans",tolua_get_BaseItem_invTrans,tolua_set_BaseItem_invTrans);
   tolua_variable(tolua_S,"invWidth",tolua_get_BaseItem_invWidth,tolua_set_BaseItem_invWidth);
   tolua_variable(tolua_S,"jamellaMagicLvl",tolua_get_BaseItem_jamellaMagicLvl,tolua_set_BaseItem_jamellaMagicLvl);
   tolua_variable(tolua_S,"jamellaMagicMax",tolua_get_BaseItem_jamellaMagicMax,tolua_set_BaseItem_jamellaMagicMax);
   tolua_variable(tolua_S,"jamellaMagicMin",tolua_get_BaseItem_jamellaMagicMin,tolua_set_BaseItem_jamellaMagicMin);
   tolua_variable(tolua_S,"jamellaMax",tolua_get_BaseItem_jamellaMax,tolua_set_BaseItem_jamellaMax);
   tolua_variable(tolua_S,"jamellaMin",tolua_get_BaseItem_jamellaMin,tolua_set_BaseItem_jamellaMin);
   tolua_variable(tolua_S,"larzukMagicLvl",tolua_get_BaseItem_larzukMagicLvl,tolua_set_BaseItem_larzukMagicLvl);
   tolua_variable(tolua_S,"larzukMagicMax",tolua_get_BaseItem_larzukMagicMax,tolua_set_BaseItem_larzukMagicMax);
   tolua_variable(tolua_S,"larzukMagicMin",tolua_get_BaseItem_larzukMagicMin,tolua_set_BaseItem_larzukMagicMin);
   tolua_variable(tolua_S,"larzukMax",tolua_get_BaseItem_larzukMax,tolua_set_BaseItem_larzukMax);
   tolua_variable(tolua_S,"larzukMin",tolua_get_BaseItem_larzukMin,tolua_set_BaseItem_larzukMin);
   tolua_variable(tolua_S,"level",tolua_get_BaseItem_level,tolua_set_BaseItem_level);
   tolua_variable(tolua_S,"levelReq",tolua_get_BaseItem_levelReq,tolua_set_BaseItem_levelReq);
   tolua_variable(tolua_S,"lightRadius",tolua_get_BaseItem_lightRadius,tolua_set_BaseItem_lightRadius);
   tolua_variable(tolua_S,"lysanderMagicLvl",tolua_get_BaseItem_lysanderMagicLvl,tolua_set_BaseItem_lysanderMagicLvl);
   tolua_variable(tolua_S,"lysanderMagicMax",tolua_get_BaseItem_lysanderMagicMax,tolua_set_BaseItem_lysanderMagicMax);
   tolua_variable(tolua_S,"lysanderMagicMin",tolua_get_BaseItem_lysanderMagicMin,tolua_set_BaseItem_lysanderMagicMin);
   tolua_variable(tolua_S,"lysanderMax",tolua_get_BaseItem_lysanderMax,tolua_set_BaseItem_lysanderMax);
   tolua_variable(tolua_S,"lysanderMin",tolua_get_BaseItem_lysanderMin,tolua_set_BaseItem_lysanderMin);
   tolua_variable(tolua_S,"malahMagicLvl",tolua_get_BaseItem_malahMagicLvl,tolua_set_BaseItem_malahMagicLvl);
   tolua_variable(tolua_S,"malahMagicMax",tolua_get_BaseItem_malahMagicMax,tolua_set_BaseItem_malahMagicMax);
   tolua_variable(tolua_S,"malahMagicMin",tolua_get_BaseItem_malahMagicMin,tolua_set_BaseItem_malahMagicMin);
   tolua_variable(tolua_S,"malahMax",tolua_get_BaseItem_malahMax,tolua_set_BaseItem_malahMax);
   tolua_variable(tolua_S,"malahMin",tolua_get_BaseItem_malahMin,tolua_set_BaseItem_malahMin);
   tolua_variable(tolua_S,"maxDamage",tolua_get_BaseItem_maxDamage,tolua_set_BaseItem_maxDamage);
   tolua_variable(tolua_S,"maxStack",tolua_get_BaseItem_maxStack,tolua_set_BaseItem_maxStack);
   tolua_variable(tolua_S,"minDamage",tolua_get_BaseItem_minDamage,tolua_set_BaseItem_minDamage);
   tolua_variable(tolua_S,"minStack",tolua_get_BaseItem_minStack,tolua_set_BaseItem_minStack);
   tolua_variable(tolua_S,"missileType",tolua_get_BaseItem_missileType,tolua_set_BaseItem_missileType);
   tolua_variable(tolua_S,"name",tolua_get_BaseItem_name,tolua_set_BaseItem_name);
   tolua_variable(tolua_S,"nameable",tolua_get_BaseItem_nameable,tolua_set_BaseItem_nameable);
   tolua_variable(tolua_S,"nameString",tolua_get_BaseItem_nameString,tolua_set_BaseItem_nameString);
   tolua_variable(tolua_S,"noDurability",tolua_get_BaseItem_noDurability,tolua_set_BaseItem_noDurability);
   tolua_variable(tolua_S,"ormusMagicLvl",tolua_get_BaseItem_ormusMagicLvl,tolua_set_BaseItem_ormusMagicLvl);
   tolua_variable(tolua_S,"ormusMagicMax",tolua_get_BaseItem_ormusMagicMax,tolua_set_BaseItem_ormusMagicMax);
   tolua_variable(tolua_S,"ormusMagicMin",tolua_get_BaseItem_ormusMagicMin,tolua_set_BaseItem_ormusMagicMin);
   tolua_variable(tolua_S,"ormusMax",tolua_get_BaseItem_ormusMax,tolua_set_BaseItem_ormusMax);
   tolua_variable(tolua_S,"ormusMin",tolua_get_BaseItem_ormusMin,tolua_set_BaseItem_ormusMin);
   tolua_variable(tolua_S,"quantityWarning",tolua_get_BaseItem_quantityWarning,tolua_set_BaseItem_quantityWarning);
   tolua_variable(tolua_S,"quest",tolua_get_BaseItem_quest,tolua_set_BaseItem_quest);
   tolua_variable(tolua_S,"rarity",tolua_get_BaseItem_rarity,tolua_set_BaseItem_rarity);
   tolua_variable(tolua_S,"skipName",tolua_get_BaseItem_skipName,tolua_set_BaseItem_skipName);
   tolua_variable(tolua_S,"sourceArt",tolua_get_BaseItem_sourceArt,tolua_set_BaseItem_sourceArt);
   tolua_variable(tolua_S,"spawnable",tolua_get_BaseItem_spawnable,tolua_set_BaseItem_spawnable);
   tolua_variable(tolua_S,"speed",tolua_get_BaseItem_speed,tolua_set_BaseItem_speed);
   tolua_variable(tolua_S,"stackable",tolua_get_BaseItem_stackable,tolua_set_BaseItem_stackable);
   tolua_variable(tolua_S,"transform",tolua_get_BaseItem_transform,tolua_set_BaseItem_transform);
   tolua_variable(tolua_S,"transparent",tolua_get_BaseItem_transparent,tolua_set_BaseItem_transparent);
   tolua_variable(tolua_S,"transTbl",tolua_get_BaseItem_transTbl,tolua_set_BaseItem_transTbl);
   tolua_variable(tolua_S,"unique",tolua_get_BaseItem_unique,tolua_set_BaseItem_unique);
   tolua_variable(tolua_S,"uniqueInvFile",tolua_get_BaseItem_uniqueInvFile,tolua_set_BaseItem_uniqueInvFile);
   tolua_variable(tolua_S,"useable",tolua_get_BaseItem_useable,tolua_set_BaseItem_useable);
   tolua_variable(tolua_S,"useSound",tolua_get_BaseItem_useSound,tolua_set_BaseItem_useSound);
   tolua_variable(tolua_S,"version",tolua_get_BaseItem_version,tolua_set_BaseItem_version);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"StatType",0);
  tolua_beginmodule(tolua_S,"StatType");
   tolua_constant(tolua_S,"None",StatType::None);
   tolua_constant(tolua_S,"Strength",StatType::Strength);
   tolua_constant(tolua_S,"Energy",StatType::Energy);
   tolua_constant(tolua_S,"Dexterity",StatType::Dexterity);
   tolua_constant(tolua_S,"Vitality",StatType::Vitality);
   tolua_constant(tolua_S,"StatPoints",StatType::StatPoints);
   tolua_constant(tolua_S,"SkillPoints",StatType::SkillPoints);
   tolua_constant(tolua_S,"Life",StatType::Life);
   tolua_constant(tolua_S,"MaxLife",StatType::MaxLife);
   tolua_constant(tolua_S,"Mana",StatType::Mana);
   tolua_constant(tolua_S,"MaxMana",StatType::MaxMana);
   tolua_constant(tolua_S,"Stamina",StatType::Stamina);
   tolua_constant(tolua_S,"MaxStamina",StatType::MaxStamina);
   tolua_constant(tolua_S,"Level",StatType::Level);
   tolua_constant(tolua_S,"Experience",StatType::Experience);
   tolua_constant(tolua_S,"Gold",StatType::Gold);
   tolua_constant(tolua_S,"GoldBank",StatType::GoldBank);
   tolua_constant(tolua_S,"DefensePercent",StatType::DefensePercent);
   tolua_constant(tolua_S,"MaxDamagePercent",StatType::MaxDamagePercent);
   tolua_constant(tolua_S,"MinDamagePercent",StatType::MinDamagePercent);
   tolua_constant(tolua_S,"ToHit",StatType::ToHit);
   tolua_constant(tolua_S,"ToBlock",StatType::ToBlock);
   tolua_constant(tolua_S,"MinDamage",StatType::MinDamage);
   tolua_constant(tolua_S,"MaxDamage",StatType::MaxDamage);
   tolua_constant(tolua_S,"SecondaryMinDamage",StatType::SecondaryMinDamage);
   tolua_constant(tolua_S,"SecondaryMaxDamage",StatType::SecondaryMaxDamage);
   tolua_constant(tolua_S,"DamagePercent",StatType::DamagePercent);
   tolua_constant(tolua_S,"ManaRecovery",StatType::ManaRecovery);
   tolua_constant(tolua_S,"ManaRecoveryBonus",StatType::ManaRecoveryBonus);
   tolua_constant(tolua_S,"StaminaRecoveryBonus",StatType::StaminaRecoveryBonus);
   tolua_constant(tolua_S,"LastExperience",StatType::LastExperience);
   tolua_constant(tolua_S,"NextExperience",StatType::NextExperience);
   tolua_constant(tolua_S,"ArmorClass",StatType::ArmorClass);
   tolua_constant(tolua_S,"ArmorClassVsMissile",StatType::ArmorClassVsMissile);
   tolua_constant(tolua_S,"ArmorClassVsMelee",StatType::ArmorClassVsMelee);
   tolua_constant(tolua_S,"DamageReduction",StatType::DamageReduction);
   tolua_constant(tolua_S,"MagicDamageReduction",StatType::MagicDamageReduction);
   tolua_constant(tolua_S,"DamageResist",StatType::DamageResist);
   tolua_constant(tolua_S,"MagicResist",StatType::MagicResist);
   tolua_constant(tolua_S,"MaxMagicResist",StatType::MaxMagicResist);
   tolua_constant(tolua_S,"FireResist",StatType::FireResist);
   tolua_constant(tolua_S,"MaxFireResist",StatType::MaxFireResist);
   tolua_constant(tolua_S,"LightResist",StatType::LightResist);
   tolua_constant(tolua_S,"MaxLightResist",StatType::MaxLightResist);
   tolua_constant(tolua_S,"ColdResist",StatType::ColdResist);
   tolua_constant(tolua_S,"MaxColdResist",StatType::MaxColdResist);
   tolua_constant(tolua_S,"PoisonResist",StatType::PoisonResist);
   tolua_constant(tolua_S,"MaxPoisonResist",StatType::MaxPoisonResist);
   tolua_constant(tolua_S,"DamageAura",StatType::DamageAura);
   tolua_constant(tolua_S,"FireMinDamage",StatType::FireMinDamage);
   tolua_constant(tolua_S,"FireMaxDamage",StatType::FireMaxDamage);
   tolua_constant(tolua_S,"LightMinDamage",StatType::LightMinDamage);
   tolua_constant(tolua_S,"LightMaxDamage",StatType::LightMaxDamage);
   tolua_constant(tolua_S,"MagicMinDamage",StatType::MagicMinDamage);
   tolua_constant(tolua_S,"MagicMaxDamage",StatType::MagicMaxDamage);
   tolua_constant(tolua_S,"ColdMinDamage",StatType::ColdMinDamage);
   tolua_constant(tolua_S,"ColdMaxDamage",StatType::ColdMaxDamage);
   tolua_constant(tolua_S,"ColdLength",StatType::ColdLength);
   tolua_constant(tolua_S,"PoisonMinDamage",StatType::PoisonMinDamage);
   tolua_constant(tolua_S,"PoisonMaxDamage",StatType::PoisonMaxDamage);
   tolua_constant(tolua_S,"PoisonLength",StatType::PoisonLength);
   tolua_constant(tolua_S,"LifeDrainMinDamage",StatType::LifeDrainMinDamage);
   tolua_constant(tolua_S,"LifeDrainMaxDamage",StatType::LifeDrainMaxDamage);
   tolua_constant(tolua_S,"ManaDrainMinDamage",StatType::ManaDrainMinDamage);
   tolua_constant(tolua_S,"ManaDrainMaxDamage",StatType::ManaDrainMaxDamage);
   tolua_constant(tolua_S,"StamDrainMinDamage",StatType::StamDrainMinDamage);
   tolua_constant(tolua_S,"StamDrainMaxDamage",StatType::StamDrainMaxDamage);
   tolua_constant(tolua_S,"StunLength",StatType::StunLength);
   tolua_constant(tolua_S,"VelocityPercent",StatType::VelocityPercent);
   tolua_constant(tolua_S,"AttackRate",StatType::AttackRate);
   tolua_constant(tolua_S,"OtherAnimRate",StatType::OtherAnimRate);
   tolua_constant(tolua_S,"Quantity",StatType::Quantity);
   tolua_constant(tolua_S,"Value",StatType::Value);
   tolua_constant(tolua_S,"Durability",StatType::Durability);
   tolua_constant(tolua_S,"MaxDurability",StatType::MaxDurability);
   tolua_constant(tolua_S,"LifeRegen",StatType::LifeRegen);
   tolua_constant(tolua_S,"MaxDurabilityPercent",StatType::MaxDurabilityPercent);
   tolua_constant(tolua_S,"MaxLifePercent",StatType::MaxLifePercent);
   tolua_constant(tolua_S,"MaxManaPercent",StatType::MaxManaPercent);
   tolua_constant(tolua_S,"AttackerTakesDamage",StatType::AttackerTakesDamage);
   tolua_constant(tolua_S,"GoldFind",StatType::GoldFind);
   tolua_constant(tolua_S,"MagicFind",StatType::MagicFind);
   tolua_constant(tolua_S,"Knockback",StatType::Knockback);
   tolua_constant(tolua_S,"TimeDuration",StatType::TimeDuration);
   tolua_constant(tolua_S,"ClassSkillsBonus",StatType::ClassSkillsBonus);
   tolua_constant(tolua_S,"UnsentParam1",StatType::UnsentParam1);
   tolua_constant(tolua_S,"AddExperience",StatType::AddExperience);
   tolua_constant(tolua_S,"HealAfterKill",StatType::HealAfterKill);
   tolua_constant(tolua_S,"ReducedPrices",StatType::ReducedPrices);
   tolua_constant(tolua_S,"DoubleHerbDuration",StatType::DoubleHerbDuration);
   tolua_constant(tolua_S,"LightRadius",StatType::LightRadius);
   tolua_constant(tolua_S,"LightColor",StatType::LightColor);
   tolua_constant(tolua_S,"LowerRequirementsPercent",StatType::LowerRequirementsPercent);
   tolua_constant(tolua_S,"LowerLevelRequirement",StatType::LowerLevelRequirement);
   tolua_constant(tolua_S,"FasterAttackRate",StatType::FasterAttackRate);
   tolua_constant(tolua_S,"LowerLevelRequirementPercent",StatType::LowerLevelRequirementPercent);
   tolua_constant(tolua_S,"LastBlockFrame",StatType::LastBlockFrame);
   tolua_constant(tolua_S,"FasterMoveVelocity",StatType::FasterMoveVelocity);
   tolua_constant(tolua_S,"NonClassSkill",StatType::NonClassSkill);
   tolua_constant(tolua_S,"State",StatType::State);
   tolua_constant(tolua_S,"FasterHitRecovery",StatType::FasterHitRecovery);
   tolua_constant(tolua_S,"MonsterPlayerCount",StatType::MonsterPlayerCount);
   tolua_constant(tolua_S,"SkillPoisonOverrideLength",StatType::SkillPoisonOverrideLength);
   tolua_constant(tolua_S,"FasterBlockRate",StatType::FasterBlockRate);
   tolua_constant(tolua_S,"SkillBypassUndead",StatType::SkillBypassUndead);
   tolua_constant(tolua_S,"SkillBypassDemons",StatType::SkillBypassDemons);
   tolua_constant(tolua_S,"FasterCastRate",StatType::FasterCastRate);
   tolua_constant(tolua_S,"SkillBypassBeasts",StatType::SkillBypassBeasts);
   tolua_constant(tolua_S,"SingleSkill",StatType::SingleSkill);
   tolua_constant(tolua_S,"RestInPeace",StatType::RestInPeace);
   tolua_constant(tolua_S,"CurseResistance",StatType::CurseResistance);
   tolua_constant(tolua_S,"PoisonLengthReduction",StatType::PoisonLengthReduction);
   tolua_constant(tolua_S,"NormalDamage",StatType::NormalDamage);
   tolua_constant(tolua_S,"Howl",StatType::Howl);
   tolua_constant(tolua_S,"HitBlindsTarget",StatType::HitBlindsTarget);
   tolua_constant(tolua_S,"DamageToMana",StatType::DamageToMana);
   tolua_constant(tolua_S,"IgnoreTargetDefense",StatType::IgnoreTargetDefense);
   tolua_constant(tolua_S,"FractionalTargetAC",StatType::FractionalTargetAC);
   tolua_constant(tolua_S,"PreventHeal",StatType::PreventHeal);
   tolua_constant(tolua_S,"HalfFreezeDuration",StatType::HalfFreezeDuration);
   tolua_constant(tolua_S,"ToHitPercent",StatType::ToHitPercent);
   tolua_constant(tolua_S,"DamageTargetAC",StatType::DamageTargetAC);
   tolua_constant(tolua_S,"DemonDamagePercent",StatType::DemonDamagePercent);
   tolua_constant(tolua_S,"UndeadDamagepercent",StatType::UndeadDamagepercent);
   tolua_constant(tolua_S,"DemonToHit",StatType::DemonToHit);
   tolua_constant(tolua_S,"UndeadToHit",StatType::UndeadToHit);
   tolua_constant(tolua_S,"Throwable",StatType::Throwable);
   tolua_constant(tolua_S,"ElementalSkillBonus",StatType::ElementalSkillBonus);
   tolua_constant(tolua_S,"AllSkillsBonus",StatType::AllSkillsBonus);
   tolua_constant(tolua_S,"AttackerTakesLightingDamage",StatType::AttackerTakesLightingDamage);
   tolua_constant(tolua_S,"IronMaidenLevel",StatType::IronMaidenLevel);
   tolua_constant(tolua_S,"LifeTapLevel",StatType::LifeTapLevel);
   tolua_constant(tolua_S,"ThornsPercent",StatType::ThornsPercent);
   tolua_constant(tolua_S,"BoneArmor",StatType::BoneArmor);
   tolua_constant(tolua_S,"BoneArmorMax",StatType::BoneArmorMax);
   tolua_constant(tolua_S,"Freeze",StatType::Freeze);
   tolua_constant(tolua_S,"OpenWounds",StatType::OpenWounds);
   tolua_constant(tolua_S,"CrushingBlow",StatType::CrushingBlow);
   tolua_constant(tolua_S,"KickDamage",StatType::KickDamage);
   tolua_constant(tolua_S,"ManaAfterKill",StatType::ManaAfterKill);
   tolua_constant(tolua_S,"HealAfterDemonKill",StatType::HealAfterDemonKill);
   tolua_constant(tolua_S,"ExtraBlood",StatType::ExtraBlood);
   tolua_constant(tolua_S,"DeadlyStrike",StatType::DeadlyStrike);
   tolua_constant(tolua_S,"AbsorbFirePercent",StatType::AbsorbFirePercent);
   tolua_constant(tolua_S,"AbsorbFire",StatType::AbsorbFire);
   tolua_constant(tolua_S,"AbsorbLightingPercent",StatType::AbsorbLightingPercent);
   tolua_constant(tolua_S,"AbsorbLight",StatType::AbsorbLight);
   tolua_constant(tolua_S,"AbsorbMagicPercent",StatType::AbsorbMagicPercent);
   tolua_constant(tolua_S,"AbsorbMagic",StatType::AbsorbMagic);
   tolua_constant(tolua_S,"AbsorbColdPercent",StatType::AbsorbColdPercent);
   tolua_constant(tolua_S,"AbsorbCold",StatType::AbsorbCold);
   tolua_constant(tolua_S,"Slow",StatType::Slow);
   tolua_constant(tolua_S,"Aura",StatType::Aura);
   tolua_constant(tolua_S,"Indesctructible",StatType::Indesctructible);
   tolua_constant(tolua_S,"CannotBeFrozen",StatType::CannotBeFrozen);
   tolua_constant(tolua_S,"StaminaDrainPercent",StatType::StaminaDrainPercent);
   tolua_constant(tolua_S,"Reanimate",StatType::Reanimate);
   tolua_constant(tolua_S,"Pierce",StatType::Pierce);
   tolua_constant(tolua_S,"MagicArrow",StatType::MagicArrow);
   tolua_constant(tolua_S,"ExplosiveArrow",StatType::ExplosiveArrow);
   tolua_constant(tolua_S,"ThrowMinDamage",StatType::ThrowMinDamage);
   tolua_constant(tolua_S,"ThrowMaxDamage",StatType::ThrowMaxDamage);
   tolua_constant(tolua_S,"SkillHandOfAthena",StatType::SkillHandOfAthena);
   tolua_constant(tolua_S,"SkillStaminaPercent",StatType::SkillStaminaPercent);
   tolua_constant(tolua_S,"SkillPassiveStaminaPercent",StatType::SkillPassiveStaminaPercent);
   tolua_constant(tolua_S,"SkillConcentration",StatType::SkillConcentration);
   tolua_constant(tolua_S,"SkillEnchant",StatType::SkillEnchant);
   tolua_constant(tolua_S,"SkillPierce",StatType::SkillPierce);
   tolua_constant(tolua_S,"SkillConviction",StatType::SkillConviction);
   tolua_constant(tolua_S,"SkillChillingArmor",StatType::SkillChillingArmor);
   tolua_constant(tolua_S,"SkillFrenzy",StatType::SkillFrenzy);
   tolua_constant(tolua_S,"SkillDecrepify",StatType::SkillDecrepify);
   tolua_constant(tolua_S,"SkillArmorPercent",StatType::SkillArmorPercent);
   tolua_constant(tolua_S,"Alignment",StatType::Alignment);
   tolua_constant(tolua_S,"Target0",StatType::Target0);
   tolua_constant(tolua_S,"Target1",StatType::Target1);
   tolua_constant(tolua_S,"GoldLost",StatType::GoldLost);
   tolua_constant(tolua_S,"ConversionLevel",StatType::ConversionLevel);
   tolua_constant(tolua_S,"ConversionMaxHP",StatType::ConversionMaxHP);
   tolua_constant(tolua_S,"UnitDoOverlay",StatType::UnitDoOverlay);
   tolua_constant(tolua_S,"AttackVsMonsterType",StatType::AttackVsMonsterType);
   tolua_constant(tolua_S,"DamageVsMonsterType",StatType::DamageVsMonsterType);
   tolua_constant(tolua_S,"Fade",StatType::Fade);
   tolua_constant(tolua_S,"ArmorOverridePercent",StatType::ArmorOverridePercent);
   tolua_constant(tolua_S,"Unused183",StatType::Unused183);
   tolua_constant(tolua_S,"Unused184",StatType::Unused184);
   tolua_constant(tolua_S,"Unused185",StatType::Unused185);
   tolua_constant(tolua_S,"Unused186",StatType::Unused186);
   tolua_constant(tolua_S,"Unused187",StatType::Unused187);
   tolua_constant(tolua_S,"SkillTabBonus",StatType::SkillTabBonus);
   tolua_constant(tolua_S,"Unused189",StatType::Unused189);
   tolua_constant(tolua_S,"Unused190",StatType::Unused190);
   tolua_constant(tolua_S,"Unused191",StatType::Unused191);
   tolua_constant(tolua_S,"Unused192",StatType::Unused192);
   tolua_constant(tolua_S,"Unused193",StatType::Unused193);
   tolua_constant(tolua_S,"Sockets",StatType::Sockets);
   tolua_constant(tolua_S,"SkillOnAttack",StatType::SkillOnAttack);
   tolua_constant(tolua_S,"SkillOnKill",StatType::SkillOnKill);
   tolua_constant(tolua_S,"SkillOnDeath",StatType::SkillOnDeath);
   tolua_constant(tolua_S,"SkillOnStriking",StatType::SkillOnStriking);
   tolua_constant(tolua_S,"SkillOnLevelUp",StatType::SkillOnLevelUp);
   tolua_constant(tolua_S,"Unused200",StatType::Unused200);
   tolua_constant(tolua_S,"SkillOnGetHit",StatType::SkillOnGetHit);
   tolua_constant(tolua_S,"Unused202",StatType::Unused202);
   tolua_constant(tolua_S,"Unused203",StatType::Unused203);
   tolua_constant(tolua_S,"ChargedSkill",StatType::ChargedSkill);
   tolua_constant(tolua_S,"Unused204",StatType::Unused204);
   tolua_constant(tolua_S,"Unused205",StatType::Unused205);
   tolua_constant(tolua_S,"Unused206",StatType::Unused206);
   tolua_constant(tolua_S,"Unused207",StatType::Unused207);
   tolua_constant(tolua_S,"Unused208",StatType::Unused208);
   tolua_constant(tolua_S,"Unused209",StatType::Unused209);
   tolua_constant(tolua_S,"Unused210",StatType::Unused210);
   tolua_constant(tolua_S,"Unused211",StatType::Unused211);
   tolua_constant(tolua_S,"Unused212",StatType::Unused212);
   tolua_constant(tolua_S,"ArmorPerLevel",StatType::ArmorPerLevel);
   tolua_constant(tolua_S,"ArmorPercentPerLevel",StatType::ArmorPercentPerLevel);
   tolua_constant(tolua_S,"LifePerLevel",StatType::LifePerLevel);
   tolua_constant(tolua_S,"ManaPerLevel",StatType::ManaPerLevel);
   tolua_constant(tolua_S,"MaxDamagePerLevel",StatType::MaxDamagePerLevel);
   tolua_constant(tolua_S,"MaxDamagePercentPerLevel",StatType::MaxDamagePercentPerLevel);
   tolua_constant(tolua_S,"StrengthPerLevel",StatType::StrengthPerLevel);
   tolua_constant(tolua_S,"DexterityPerLevel",StatType::DexterityPerLevel);
   tolua_constant(tolua_S,"EnergyPerLevel",StatType::EnergyPerLevel);
   tolua_constant(tolua_S,"VitalityPerLevel",StatType::VitalityPerLevel);
   tolua_constant(tolua_S,"ToHitPerLevel",StatType::ToHitPerLevel);
   tolua_constant(tolua_S,"ToHitPercentPerLevel",StatType::ToHitPercentPerLevel);
   tolua_constant(tolua_S,"ColdDamageMaxPerLevel",StatType::ColdDamageMaxPerLevel);
   tolua_constant(tolua_S,"FireDamageMaxPerLevel",StatType::FireDamageMaxPerLevel);
   tolua_constant(tolua_S,"LightningDamageMaxPerLevel",StatType::LightningDamageMaxPerLevel);
   tolua_constant(tolua_S,"PoisonDamageMaxPerLevel",StatType::PoisonDamageMaxPerLevel);
   tolua_constant(tolua_S,"ResistColdPerLevel",StatType::ResistColdPerLevel);
   tolua_constant(tolua_S,"ResistFirePerLevel",StatType::ResistFirePerLevel);
   tolua_constant(tolua_S,"ResistLightningPerLevel",StatType::ResistLightningPerLevel);
   tolua_constant(tolua_S,"ResistPoisonPerLevel",StatType::ResistPoisonPerLevel);
   tolua_constant(tolua_S,"AbsorbColdPerLevel",StatType::AbsorbColdPerLevel);
   tolua_constant(tolua_S,"AbsorbFirePerLevel",StatType::AbsorbFirePerLevel);
   tolua_constant(tolua_S,"AbsorbLightningPerLevel",StatType::AbsorbLightningPerLevel);
   tolua_constant(tolua_S,"AbsorbPoisonPerLevel",StatType::AbsorbPoisonPerLevel);
   tolua_constant(tolua_S,"ThornsPerLevel",StatType::ThornsPerLevel);
   tolua_constant(tolua_S,"GoldFindPerLevel",StatType::GoldFindPerLevel);
   tolua_constant(tolua_S,"MagicFindPerLevel",StatType::MagicFindPerLevel);
   tolua_constant(tolua_S,"RegenStaminaPerLevel",StatType::RegenStaminaPerLevel);
   tolua_constant(tolua_S,"StaminaPerLevel",StatType::StaminaPerLevel);
   tolua_constant(tolua_S,"DamageDemonPerLevel",StatType::DamageDemonPerLevel);
   tolua_constant(tolua_S,"DamageUndeadPerLevel",StatType::DamageUndeadPerLevel);
   tolua_constant(tolua_S,"ToHitDemonPerLevel",StatType::ToHitDemonPerLevel);
   tolua_constant(tolua_S,"ToHitUndeadPerLevel",StatType::ToHitUndeadPerLevel);
   tolua_constant(tolua_S,"CrushingBlowPerLevel",StatType::CrushingBlowPerLevel);
   tolua_constant(tolua_S,"OpenWoundsPerLevel",StatType::OpenWoundsPerLevel);
   tolua_constant(tolua_S,"KickDamagePerLevel",StatType::KickDamagePerLevel);
   tolua_constant(tolua_S,"DeadlyStrikePerLevel",StatType::DeadlyStrikePerLevel);
   tolua_constant(tolua_S,"FindGemsPerLevel",StatType::FindGemsPerLevel);
   tolua_constant(tolua_S,"ReplenishDurability",StatType::ReplenishDurability);
   tolua_constant(tolua_S,"ReplenishQuantity",StatType::ReplenishQuantity);
   tolua_constant(tolua_S,"ExtraStack",StatType::ExtraStack);
   tolua_constant(tolua_S,"FindItem",StatType::FindItem);
   tolua_constant(tolua_S,"SlashDamage",StatType::SlashDamage);
   tolua_constant(tolua_S,"SlashDamagePercent",StatType::SlashDamagePercent);
   tolua_constant(tolua_S,"CrushDamage",StatType::CrushDamage);
   tolua_constant(tolua_S,"CrushDamagePercent",StatType::CrushDamagePercent);
   tolua_constant(tolua_S,"ThrustDamage",StatType::ThrustDamage);
   tolua_constant(tolua_S,"ThrustDamagePercent",StatType::ThrustDamagePercent);
   tolua_constant(tolua_S,"AbsorbSlash",StatType::AbsorbSlash);
   tolua_constant(tolua_S,"AbsorbCrush",StatType::AbsorbCrush);
   tolua_constant(tolua_S,"AbsorbThrust",StatType::AbsorbThrust);
   tolua_constant(tolua_S,"AbsorbSlashPercent",StatType::AbsorbSlashPercent);
   tolua_constant(tolua_S,"AbsorbCrushPercent",StatType::AbsorbCrushPercent);
   tolua_constant(tolua_S,"AbsorbThrustPercent",StatType::AbsorbThrustPercent);
   tolua_constant(tolua_S,"ArmorByTime",StatType::ArmorByTime);
   tolua_constant(tolua_S,"ArmorPercentByTime",StatType::ArmorPercentByTime);
   tolua_constant(tolua_S,"LifeByTime",StatType::LifeByTime);
   tolua_constant(tolua_S,"ManaByTime",StatType::ManaByTime);
   tolua_constant(tolua_S,"MaxDamageByTime",StatType::MaxDamageByTime);
   tolua_constant(tolua_S,"MaxDamagePercentByTime",StatType::MaxDamagePercentByTime);
   tolua_constant(tolua_S,"StrengthByTime",StatType::StrengthByTime);
   tolua_constant(tolua_S,"DexterityByTime",StatType::DexterityByTime);
   tolua_constant(tolua_S,"EnergyByTime",StatType::EnergyByTime);
   tolua_constant(tolua_S,"VitalityByTime",StatType::VitalityByTime);
   tolua_constant(tolua_S,"ToHitByTime",StatType::ToHitByTime);
   tolua_constant(tolua_S,"ToHitPercentByTime",StatType::ToHitPercentByTime);
   tolua_constant(tolua_S,"ColdMaxDamageByTime",StatType::ColdMaxDamageByTime);
   tolua_constant(tolua_S,"FireMaxDamageByTime",StatType::FireMaxDamageByTime);
   tolua_constant(tolua_S,"LightningMaxDamageByTime",StatType::LightningMaxDamageByTime);
   tolua_constant(tolua_S,"PoisonMaxDamageByTime",StatType::PoisonMaxDamageByTime);
   tolua_constant(tolua_S,"ResistColdByTime",StatType::ResistColdByTime);
   tolua_constant(tolua_S,"ResistFireByTime",StatType::ResistFireByTime);
   tolua_constant(tolua_S,"ResistLightningByTime",StatType::ResistLightningByTime);
   tolua_constant(tolua_S,"ResistPoisonByTime",StatType::ResistPoisonByTime);
   tolua_constant(tolua_S,"AbsorbColdByTime",StatType::AbsorbColdByTime);
   tolua_constant(tolua_S,"AbsorbFireByTime",StatType::AbsorbFireByTime);
   tolua_constant(tolua_S,"AbsorbLightningByTime",StatType::AbsorbLightningByTime);
   tolua_constant(tolua_S,"AbsorbPoisonByTime",StatType::AbsorbPoisonByTime);
   tolua_constant(tolua_S,"FindGoldByTime",StatType::FindGoldByTime);
   tolua_constant(tolua_S,"FindMagicByTime",StatType::FindMagicByTime);
   tolua_constant(tolua_S,"RegenStaminaByTime",StatType::RegenStaminaByTime);
   tolua_constant(tolua_S,"StaminaByTime",StatType::StaminaByTime);
   tolua_constant(tolua_S,"DamageDemonByTime",StatType::DamageDemonByTime);
   tolua_constant(tolua_S,"DamageUndeadByTime",StatType::DamageUndeadByTime);
   tolua_constant(tolua_S,"ToHitDemonByTime",StatType::ToHitDemonByTime);
   tolua_constant(tolua_S,"ToHitUndeadByTime",StatType::ToHitUndeadByTime);
   tolua_constant(tolua_S,"CrushingBlowByTime",StatType::CrushingBlowByTime);
   tolua_constant(tolua_S,"OpenWoundsByTime",StatType::OpenWoundsByTime);
   tolua_constant(tolua_S,"KickDamageByTime",StatType::KickDamageByTime);
   tolua_constant(tolua_S,"DeadlyStrikeByTime",StatType::DeadlyStrikeByTime);
   tolua_constant(tolua_S,"FindGemsByTime",StatType::FindGemsByTime);
   tolua_constant(tolua_S,"PierceCold",StatType::PierceCold);
   tolua_constant(tolua_S,"PierceFire",StatType::PierceFire);
   tolua_constant(tolua_S,"PierceLightning",StatType::PierceLightning);
   tolua_constant(tolua_S,"PiercePoison",StatType::PiercePoison);
   tolua_constant(tolua_S,"DamageVsMonster",StatType::DamageVsMonster);
   tolua_constant(tolua_S,"DamagePercentVsMonster",StatType::DamagePercentVsMonster);
   tolua_constant(tolua_S,"ToHitVsMonster",StatType::ToHitVsMonster);
   tolua_constant(tolua_S,"ToHitPercentVsMonster",StatType::ToHitPercentVsMonster);
   tolua_constant(tolua_S,"DefenseVsMonster",StatType::DefenseVsMonster);
   tolua_constant(tolua_S,"DefensePercentVsMonster",StatType::DefensePercentVsMonster);
   tolua_constant(tolua_S,"FireLength",StatType::FireLength);
   tolua_constant(tolua_S,"BurningMin",StatType::BurningMin);
   tolua_constant(tolua_S,"BurningMax",StatType::BurningMax);
   tolua_constant(tolua_S,"ProgressiveDamage",StatType::ProgressiveDamage);
   tolua_constant(tolua_S,"ProgressiveSteal",StatType::ProgressiveSteal);
   tolua_constant(tolua_S,"ProgressiveOther",StatType::ProgressiveOther);
   tolua_constant(tolua_S,"ProgressiveFire",StatType::ProgressiveFire);
   tolua_constant(tolua_S,"ProgressiveCold",StatType::ProgressiveCold);
   tolua_constant(tolua_S,"ProgressiveLightning",StatType::ProgressiveLightning);
   tolua_constant(tolua_S,"ExtraCharges",StatType::ExtraCharges);
   tolua_constant(tolua_S,"ProgressiveToHit",StatType::ProgressiveToHit);
   tolua_constant(tolua_S,"PoisonCount",StatType::PoisonCount);
   tolua_constant(tolua_S,"DamageFramerate",StatType::DamageFramerate);
   tolua_constant(tolua_S,"PierceIdx",StatType::PierceIdx);
   tolua_constant(tolua_S,"PassiveFireMastery",StatType::PassiveFireMastery);
   tolua_constant(tolua_S,"PassiveLightningMastery",StatType::PassiveLightningMastery);
   tolua_constant(tolua_S,"PassiveColdMastery",StatType::PassiveColdMastery);
   tolua_constant(tolua_S,"PassivePoisonMastery",StatType::PassivePoisonMastery);
   tolua_constant(tolua_S,"PassiveFirePierce",StatType::PassiveFirePierce);
   tolua_constant(tolua_S,"PassiveLightningPierce",StatType::PassiveLightningPierce);
   tolua_constant(tolua_S,"PassiveColdPierce",StatType::PassiveColdPierce);
   tolua_constant(tolua_S,"PassivePoisonPierce",StatType::PassivePoisonPierce);
   tolua_constant(tolua_S,"PassiveCriticalStrike",StatType::PassiveCriticalStrike);
   tolua_constant(tolua_S,"PassiveDodge",StatType::PassiveDodge);
   tolua_constant(tolua_S,"PassiveAvoid",StatType::PassiveAvoid);
   tolua_constant(tolua_S,"PassiveEvade",StatType::PassiveEvade);
   tolua_constant(tolua_S,"PassiveWarmth",StatType::PassiveWarmth);
   tolua_constant(tolua_S,"PassiveMasteryMeleeToHit",StatType::PassiveMasteryMeleeToHit);
   tolua_constant(tolua_S,"PassiveMasteryMeleeDamage",StatType::PassiveMasteryMeleeDamage);
   tolua_constant(tolua_S,"PassiveMasteryMeleeCritical",StatType::PassiveMasteryMeleeCritical);
   tolua_constant(tolua_S,"PassiveMasteryThrowToHit",StatType::PassiveMasteryThrowToHit);
   tolua_constant(tolua_S,"PassiveMasteryThrowDamage",StatType::PassiveMasteryThrowDamage);
   tolua_constant(tolua_S,"PassiveMasteryThrowCritical",StatType::PassiveMasteryThrowCritical);
   tolua_constant(tolua_S,"PassiveWeaponBlock",StatType::PassiveWeaponBlock);
   tolua_constant(tolua_S,"PassiveSummon_resist",StatType::PassiveSummon_resist);
   tolua_constant(tolua_S,"ModifierListSkill",StatType::ModifierListSkill);
   tolua_constant(tolua_S,"ModifierListLevel",StatType::ModifierListLevel);
   tolua_constant(tolua_S,"LastSentLifePercent",StatType::LastSentLifePercent);
   tolua_constant(tolua_S,"SourceUnitType",StatType::SourceUnitType);
   tolua_constant(tolua_S,"SourceUnitID",StatType::SourceUnitID);
   tolua_constant(tolua_S,"ShortParam1",StatType::ShortParam1);
   tolua_constant(tolua_S,"QuestItemDifficulty",StatType::QuestItemDifficulty);
   tolua_constant(tolua_S,"PassiveMagicMastery",StatType::PassiveMagicMastery);
   tolua_constant(tolua_S,"PassiveMagicPierce",StatType::PassiveMagicPierce);
   tolua_constant(tolua_S,"Invalid",StatType::Invalid);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"ItemSetType",0);
  tolua_beginmodule(tolua_S,"ItemSetType");
   tolua_constant(tolua_S,"CiverbsVestments",ItemSetType::CiverbsVestments);
   tolua_constant(tolua_S,"HsarusDefense",ItemSetType::HsarusDefense);
   tolua_constant(tolua_S,"CleglawsBrace",ItemSetType::CleglawsBrace);
   tolua_constant(tolua_S,"IrathasFinery",ItemSetType::IrathasFinery);
   tolua_constant(tolua_S,"IsenhartsArmory",ItemSetType::IsenhartsArmory);
   tolua_constant(tolua_S,"VidalasRig",ItemSetType::VidalasRig);
   tolua_constant(tolua_S,"MilabregasRegalia",ItemSetType::MilabregasRegalia);
   tolua_constant(tolua_S,"CathansTraps",ItemSetType::CathansTraps);
   tolua_constant(tolua_S,"TancredsBattlegear",ItemSetType::TancredsBattlegear);
   tolua_constant(tolua_S,"SigonsCompleteSteel",ItemSetType::SigonsCompleteSteel);
   tolua_constant(tolua_S,"InfernalTools",ItemSetType::InfernalTools);
   tolua_constant(tolua_S,"BerserkersGarb",ItemSetType::BerserkersGarb);
   tolua_constant(tolua_S,"DeathsDisguise",ItemSetType::DeathsDisguise);
   tolua_constant(tolua_S,"AngelicalRaiment",ItemSetType::AngelicalRaiment);
   tolua_constant(tolua_S,"ArcticGear",ItemSetType::ArcticGear);
   tolua_constant(tolua_S,"ArcannasTricks",ItemSetType::ArcannasTricks);
   tolua_constant(tolua_S,"NatalyasOdium",ItemSetType::NatalyasOdium);
   tolua_constant(tolua_S,"AldursWatchtower",ItemSetType::AldursWatchtower);
   tolua_constant(tolua_S,"ImmortalKing",ItemSetType::ImmortalKing);
   tolua_constant(tolua_S,"TalRashasWrappings",ItemSetType::TalRashasWrappings);
   tolua_constant(tolua_S,"GriswoldsLegacy",ItemSetType::GriswoldsLegacy);
   tolua_constant(tolua_S,"TrangOulsAvatar",ItemSetType::TrangOulsAvatar);
   tolua_constant(tolua_S,"MavinasBattleHymn",ItemSetType::MavinasBattleHymn);
   tolua_constant(tolua_S,"TheDisciple",ItemSetType::TheDisciple);
   tolua_constant(tolua_S,"HeavensBrethren",ItemSetType::HeavensBrethren);
   tolua_constant(tolua_S,"OrphansCall",ItemSetType::OrphansCall);
   tolua_constant(tolua_S,"HwaninsMajesty",ItemSetType::HwaninsMajesty);
   tolua_constant(tolua_S,"SazabisGrandTribute",ItemSetType::SazabisGrandTribute);
   tolua_constant(tolua_S,"BulKathosChildren",ItemSetType::BulKathosChildren);
   tolua_constant(tolua_S,"CowKingsLeathers",ItemSetType::CowKingsLeathers);
   tolua_constant(tolua_S,"NajsAncientSet",ItemSetType::NajsAncientSet);
   tolua_constant(tolua_S,"McAuleysFolly",ItemSetType::McAuleysFolly);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"UniqueItemType",0);
  tolua_beginmodule(tolua_S,"UniqueItemType");
   tolua_constant(tolua_S,"TheGnasher",UniqueItemType::TheGnasher);
   tolua_constant(tolua_S,"Deathspade",UniqueItemType::Deathspade);
   tolua_constant(tolua_S,"Bladebone",UniqueItemType::Bladebone);
   tolua_constant(tolua_S,"Mindrend",UniqueItemType::Mindrend);
   tolua_constant(tolua_S,"Rakescar",UniqueItemType::Rakescar);
   tolua_constant(tolua_S,"FechmarsAxe",UniqueItemType::FechmarsAxe);
   tolua_constant(tolua_S,"Goreshovel",UniqueItemType::Goreshovel);
   tolua_constant(tolua_S,"TheChieftan",UniqueItemType::TheChieftan);
   tolua_constant(tolua_S,"Brainhew",UniqueItemType::Brainhew);
   tolua_constant(tolua_S,"TheHumongous",UniqueItemType::TheHumongous);
   tolua_constant(tolua_S,"IrosTorch",UniqueItemType::IrosTorch);
   tolua_constant(tolua_S,"Maelstrom",UniqueItemType::Maelstrom);
   tolua_constant(tolua_S,"Gravenspine",UniqueItemType::Gravenspine);
   tolua_constant(tolua_S,"UmesLament",UniqueItemType::UmesLament);
   tolua_constant(tolua_S,"Felloak",UniqueItemType::Felloak);
   tolua_constant(tolua_S,"KnellStriker",UniqueItemType::KnellStriker);
   tolua_constant(tolua_S,"Rusthandle",UniqueItemType::Rusthandle);
   tolua_constant(tolua_S,"Stormeye",UniqueItemType::Stormeye);
   tolua_constant(tolua_S,"Stoutnail",UniqueItemType::Stoutnail);
   tolua_constant(tolua_S,"Crushflange",UniqueItemType::Crushflange);
   tolua_constant(tolua_S,"Bloodrise",UniqueItemType::Bloodrise);
   tolua_constant(tolua_S,"TheGeneralsTanDoLiGa",UniqueItemType::TheGeneralsTanDoLiGa);
   tolua_constant(tolua_S,"Ironstone",UniqueItemType::Ironstone);
   tolua_constant(tolua_S,"Bonesob",UniqueItemType::Bonesob);
   tolua_constant(tolua_S,"Steeldriver",UniqueItemType::Steeldriver);
   tolua_constant(tolua_S,"RixotsKeen",UniqueItemType::RixotsKeen);
   tolua_constant(tolua_S,"BloodCrescent",UniqueItemType::BloodCrescent);
   tolua_constant(tolua_S,"KrintizsSkewer",UniqueItemType::KrintizsSkewer);
   tolua_constant(tolua_S,"Gleamscythe",UniqueItemType::Gleamscythe);
   tolua_constant(tolua_S,"azurewrath1",UniqueItemType::azurewrath1);
   tolua_constant(tolua_S,"GriswoldsEdge",UniqueItemType::GriswoldsEdge);
   tolua_constant(tolua_S,"Hellplague",UniqueItemType::Hellplague);
   tolua_constant(tolua_S,"CulwensPoint",UniqueItemType::CulwensPoint);
   tolua_constant(tolua_S,"Shadowfang",UniqueItemType::Shadowfang);
   tolua_constant(tolua_S,"Soulflay",UniqueItemType::Soulflay);
   tolua_constant(tolua_S,"KinemilsAwl",UniqueItemType::KinemilsAwl);
   tolua_constant(tolua_S,"Blacktongue",UniqueItemType::Blacktongue);
   tolua_constant(tolua_S,"Ripsaw",UniqueItemType::Ripsaw);
   tolua_constant(tolua_S,"ThePatriarch",UniqueItemType::ThePatriarch);
   tolua_constant(tolua_S,"Gull",UniqueItemType::Gull);
   tolua_constant(tolua_S,"TheDiggler",UniqueItemType::TheDiggler);
   tolua_constant(tolua_S,"TheJadeTanDo",UniqueItemType::TheJadeTanDo);
   tolua_constant(tolua_S,"IricesShard",UniqueItemType::IricesShard);
   tolua_constant(tolua_S,"TheDragonChang",UniqueItemType::TheDragonChang);
   tolua_constant(tolua_S,"Razortine",UniqueItemType::Razortine);
   tolua_constant(tolua_S,"Bloodthief",UniqueItemType::Bloodthief);
   tolua_constant(tolua_S,"LanceofYaggai",UniqueItemType::LanceofYaggai);
   tolua_constant(tolua_S,"TheTannrGorerod",UniqueItemType::TheTannrGorerod);
   tolua_constant(tolua_S,"DimoaksHew",UniqueItemType::DimoaksHew);
   tolua_constant(tolua_S,"Steelgoad",UniqueItemType::Steelgoad);
   tolua_constant(tolua_S,"SoulHarvest",UniqueItemType::SoulHarvest);
   tolua_constant(tolua_S,"TheBattlebranch",UniqueItemType::TheBattlebranch);
   tolua_constant(tolua_S,"Woestave",UniqueItemType::Woestave);
   tolua_constant(tolua_S,"TheGrimReaper",UniqueItemType::TheGrimReaper);
   tolua_constant(tolua_S,"BaneAsh",UniqueItemType::BaneAsh);
   tolua_constant(tolua_S,"SerpentLord",UniqueItemType::SerpentLord);
   tolua_constant(tolua_S,"LazarusSpire",UniqueItemType::LazarusSpire);
   tolua_constant(tolua_S,"TheSalamander",UniqueItemType::TheSalamander);
   tolua_constant(tolua_S,"TheIronJangBong",UniqueItemType::TheIronJangBong);
   tolua_constant(tolua_S,"Pluckeye",UniqueItemType::Pluckeye);
   tolua_constant(tolua_S,"Witherstring",UniqueItemType::Witherstring);
   tolua_constant(tolua_S,"Rimeraven",UniqueItemType::Rimeraven);
   tolua_constant(tolua_S,"Piercerib",UniqueItemType::Piercerib);
   tolua_constant(tolua_S,"Pullspite",UniqueItemType::Pullspite);
   tolua_constant(tolua_S,"Wizendraw",UniqueItemType::Wizendraw);
   tolua_constant(tolua_S,"Hellclap",UniqueItemType::Hellclap);
   tolua_constant(tolua_S,"Blastbark",UniqueItemType::Blastbark);
   tolua_constant(tolua_S,"Leadcrow",UniqueItemType::Leadcrow);
   tolua_constant(tolua_S,"Ichorsting",UniqueItemType::Ichorsting);
   tolua_constant(tolua_S,"Hellcast",UniqueItemType::Hellcast);
   tolua_constant(tolua_S,"Doomspittle",UniqueItemType::Doomspittle);
   tolua_constant(tolua_S,"WarBonnet",UniqueItemType::WarBonnet);
   tolua_constant(tolua_S,"Tarnhelm",UniqueItemType::Tarnhelm);
   tolua_constant(tolua_S,"CoifofGlory",UniqueItemType::CoifofGlory);
   tolua_constant(tolua_S,"Duskdeep",UniqueItemType::Duskdeep);
   tolua_constant(tolua_S,"Wormskull",UniqueItemType::Wormskull);
   tolua_constant(tolua_S,"Howltusk",UniqueItemType::Howltusk);
   tolua_constant(tolua_S,"UndeadCrown",UniqueItemType::UndeadCrown);
   tolua_constant(tolua_S,"TheFaceofHorror",UniqueItemType::TheFaceofHorror);
   tolua_constant(tolua_S,"Greyform",UniqueItemType::Greyform);
   tolua_constant(tolua_S,"BlinkbatsForm",UniqueItemType::BlinkbatsForm);
   tolua_constant(tolua_S,"TheCenturion",UniqueItemType::TheCenturion);
   tolua_constant(tolua_S,"Twitchthroe",UniqueItemType::Twitchthroe);
   tolua_constant(tolua_S,"Darkglow",UniqueItemType::Darkglow);
   tolua_constant(tolua_S,"Hawkmail",UniqueItemType::Hawkmail);
   tolua_constant(tolua_S,"SparkingMail",UniqueItemType::SparkingMail);
   tolua_constant(tolua_S,"Venomsward",UniqueItemType::Venomsward);
   tolua_constant(tolua_S,"Iceblink",UniqueItemType::Iceblink);
   tolua_constant(tolua_S,"Boneflesh",UniqueItemType::Boneflesh);
   tolua_constant(tolua_S,"Rockfleece",UniqueItemType::Rockfleece);
   tolua_constant(tolua_S,"Rattlecage",UniqueItemType::Rattlecage);
   tolua_constant(tolua_S,"Goldskin",UniqueItemType::Goldskin);
   tolua_constant(tolua_S,"VictorsSilk",UniqueItemType::VictorsSilk);
   tolua_constant(tolua_S,"HeavenlyGarb",UniqueItemType::HeavenlyGarb);
   tolua_constant(tolua_S,"PeltaLunata",UniqueItemType::PeltaLunata);
   tolua_constant(tolua_S,"UmbralDisk",UniqueItemType::UmbralDisk);
   tolua_constant(tolua_S,"Stormguild",UniqueItemType::Stormguild);
   tolua_constant(tolua_S,"WalloftheEyeless",UniqueItemType::WalloftheEyeless);
   tolua_constant(tolua_S,"SwordbackHold",UniqueItemType::SwordbackHold);
   tolua_constant(tolua_S,"Steelclash",UniqueItemType::Steelclash);
   tolua_constant(tolua_S,"BverritKeep",UniqueItemType::BverritKeep);
   tolua_constant(tolua_S,"TheWard",UniqueItemType::TheWard);
   tolua_constant(tolua_S,"TheHandofBroc",UniqueItemType::TheHandofBroc);
   tolua_constant(tolua_S,"Bloodfist",UniqueItemType::Bloodfist);
   tolua_constant(tolua_S,"ChanceGuards",UniqueItemType::ChanceGuards);
   tolua_constant(tolua_S,"Magefist",UniqueItemType::Magefist);
   tolua_constant(tolua_S,"Frostburn",UniqueItemType::Frostburn);
   tolua_constant(tolua_S,"Hotspur",UniqueItemType::Hotspur);
   tolua_constant(tolua_S,"Gorefoot",UniqueItemType::Gorefoot);
   tolua_constant(tolua_S,"TreadsofCthon",UniqueItemType::TreadsofCthon);
   tolua_constant(tolua_S,"GoblinToe",UniqueItemType::GoblinToe);
   tolua_constant(tolua_S,"Tearhaunch",UniqueItemType::Tearhaunch);
   tolua_constant(tolua_S,"LenymsCord",UniqueItemType::LenymsCord);
   tolua_constant(tolua_S,"Snakecord",UniqueItemType::Snakecord);
   tolua_constant(tolua_S,"Nightsmoke",UniqueItemType::Nightsmoke);
   tolua_constant(tolua_S,"Goldwrap",UniqueItemType::Goldwrap);
   tolua_constant(tolua_S,"Bladebuckle",UniqueItemType::Bladebuckle);
   tolua_constant(tolua_S,"NokozanRelic",UniqueItemType::NokozanRelic);
   tolua_constant(tolua_S,"TheEyeofEtlich",UniqueItemType::TheEyeofEtlich);
   tolua_constant(tolua_S,"TheMahimOakCurio",UniqueItemType::TheMahimOakCurio);
   tolua_constant(tolua_S,"Nagelring",UniqueItemType::Nagelring);
   tolua_constant(tolua_S,"ManaldHeal",UniqueItemType::ManaldHeal);
   tolua_constant(tolua_S,"TheStoneofJordan",UniqueItemType::TheStoneofJordan);
   tolua_constant(tolua_S,"AmuletoftheViper",UniqueItemType::AmuletoftheViper);
   tolua_constant(tolua_S,"StaffofKings",UniqueItemType::StaffofKings);
   tolua_constant(tolua_S,"HoradricStaff",UniqueItemType::HoradricStaff);
   tolua_constant(tolua_S,"HellForgeHammer",UniqueItemType::HellForgeHammer);
   tolua_constant(tolua_S,"KhalimFlail",UniqueItemType::KhalimFlail);
   tolua_constant(tolua_S,"SuperKhalimFlail",UniqueItemType::SuperKhalimFlail);
   tolua_constant(tolua_S,"Coldkill",UniqueItemType::Coldkill);
   tolua_constant(tolua_S,"ButchersPupil",UniqueItemType::ButchersPupil);
   tolua_constant(tolua_S,"Islestrike",UniqueItemType::Islestrike);
   tolua_constant(tolua_S,"PompesWrath",UniqueItemType::PompesWrath);
   tolua_constant(tolua_S,"GuardianNaga",UniqueItemType::GuardianNaga);
   tolua_constant(tolua_S,"WarlordsTrust",UniqueItemType::WarlordsTrust);
   tolua_constant(tolua_S,"Spellsteel",UniqueItemType::Spellsteel);
   tolua_constant(tolua_S,"Stormrider",UniqueItemType::Stormrider);
   tolua_constant(tolua_S,"BoneslayerBlade",UniqueItemType::BoneslayerBlade);
   tolua_constant(tolua_S,"TheMinataur",UniqueItemType::TheMinataur);
   tolua_constant(tolua_S,"SuicideBranch",UniqueItemType::SuicideBranch);
   tolua_constant(tolua_S,"CarinShard",UniqueItemType::CarinShard);
   tolua_constant(tolua_S,"ArmofKingLeoric",UniqueItemType::ArmofKingLeoric);
   tolua_constant(tolua_S,"BlackhandKey",UniqueItemType::BlackhandKey);
   tolua_constant(tolua_S,"DarkClanCrusher",UniqueItemType::DarkClanCrusher);
   tolua_constant(tolua_S,"ZakarumsHand",UniqueItemType::ZakarumsHand);
   tolua_constant(tolua_S,"TheFetidSprinkler",UniqueItemType::TheFetidSprinkler);
   tolua_constant(tolua_S,"HandofBlessedLight",UniqueItemType::HandofBlessedLight);
   tolua_constant(tolua_S,"Fleshrender",UniqueItemType::Fleshrender);
   tolua_constant(tolua_S,"SureshrillFrost",UniqueItemType::SureshrillFrost);
   tolua_constant(tolua_S,"Moonfall",UniqueItemType::Moonfall);
   tolua_constant(tolua_S,"BaezilsVortex",UniqueItemType::BaezilsVortex);
   tolua_constant(tolua_S,"Earthshaker",UniqueItemType::Earthshaker);
   tolua_constant(tolua_S,"BloodtreeStump",UniqueItemType::BloodtreeStump);
   tolua_constant(tolua_S,"TheGavelofPain",UniqueItemType::TheGavelofPain);
   tolua_constant(tolua_S,"Bloodletter",UniqueItemType::Bloodletter);
   tolua_constant(tolua_S,"ColdsteelEye",UniqueItemType::ColdsteelEye);
   tolua_constant(tolua_S,"Hexfire",UniqueItemType::Hexfire);
   tolua_constant(tolua_S,"BladeofAliBaba",UniqueItemType::BladeofAliBaba);
   tolua_constant(tolua_S,"GinthersRift",UniqueItemType::GinthersRift);
   tolua_constant(tolua_S,"Headstriker",UniqueItemType::Headstriker);
   tolua_constant(tolua_S,"PlagueBearer",UniqueItemType::PlagueBearer);
   tolua_constant(tolua_S,"TheAtlantian",UniqueItemType::TheAtlantian);
   tolua_constant(tolua_S,"CrainteVomir",UniqueItemType::CrainteVomir);
   tolua_constant(tolua_S,"BingSzWang",UniqueItemType::BingSzWang);
   tolua_constant(tolua_S,"TheVileHusk",UniqueItemType::TheVileHusk);
   tolua_constant(tolua_S,"Cloudcrack",UniqueItemType::Cloudcrack);
   tolua_constant(tolua_S,"TodesfaelleFlamme",UniqueItemType::TodesfaelleFlamme);
   tolua_constant(tolua_S,"Swordguard",UniqueItemType::Swordguard);
   tolua_constant(tolua_S,"Spineripper",UniqueItemType::Spineripper);
   tolua_constant(tolua_S,"HeartCarver",UniqueItemType::HeartCarver);
   tolua_constant(tolua_S,"BlackbogsSharp",UniqueItemType::BlackbogsSharp);
   tolua_constant(tolua_S,"Stormspike",UniqueItemType::Stormspike);
   tolua_constant(tolua_S,"TheImpaler",UniqueItemType::TheImpaler);
   tolua_constant(tolua_S,"KelpieSnare",UniqueItemType::KelpieSnare);
   tolua_constant(tolua_S,"SoulfeastTine",UniqueItemType::SoulfeastTine);
   tolua_constant(tolua_S,"HoneSundan",UniqueItemType::HoneSundan);
   tolua_constant(tolua_S,"SpireofHonor",UniqueItemType::SpireofHonor);
   tolua_constant(tolua_S,"TheMeatScraper",UniqueItemType::TheMeatScraper);
   tolua_constant(tolua_S,"BlackleachBlade",UniqueItemType::BlackleachBlade);
   tolua_constant(tolua_S,"AthenasWrath",UniqueItemType::AthenasWrath);
   tolua_constant(tolua_S,"PierreTombaleCouant",UniqueItemType::PierreTombaleCouant);
   tolua_constant(tolua_S,"HusoldalEvo",UniqueItemType::HusoldalEvo);
   tolua_constant(tolua_S,"GrimsBurningDead",UniqueItemType::GrimsBurningDead);
   tolua_constant(tolua_S,"Razorswitch",UniqueItemType::Razorswitch);
   tolua_constant(tolua_S,"Ribcracker",UniqueItemType::Ribcracker);
   tolua_constant(tolua_S,"ChromaticIre",UniqueItemType::ChromaticIre);
   tolua_constant(tolua_S,"Warpspear",UniqueItemType::Warpspear);
   tolua_constant(tolua_S,"Skullcollector",UniqueItemType::Skullcollector);
   tolua_constant(tolua_S,"Skystrike",UniqueItemType::Skystrike);
   tolua_constant(tolua_S,"Riphook",UniqueItemType::Riphook);
   tolua_constant(tolua_S,"KukoShakaku",UniqueItemType::KukoShakaku);
   tolua_constant(tolua_S,"Endlesshail",UniqueItemType::Endlesshail);
   tolua_constant(tolua_S,"WhichwildString",UniqueItemType::WhichwildString);
   tolua_constant(tolua_S,"Cliffkiller",UniqueItemType::Cliffkiller);
   tolua_constant(tolua_S,"Magewrath",UniqueItemType::Magewrath);
   tolua_constant(tolua_S,"GodstrikeArch",UniqueItemType::GodstrikeArch);
   tolua_constant(tolua_S,"LangerBriser",UniqueItemType::LangerBriser);
   tolua_constant(tolua_S,"PusSpiter",UniqueItemType::PusSpiter);
   tolua_constant(tolua_S,"BurizaDoKyanon",UniqueItemType::BurizaDoKyanon);
   tolua_constant(tolua_S,"DemonMachine",UniqueItemType::DemonMachine);
   tolua_constant(tolua_S,"Armor",UniqueItemType::Armor);
   tolua_constant(tolua_S,"PeasentCrown",UniqueItemType::PeasentCrown);
   tolua_constant(tolua_S,"Rockstopper",UniqueItemType::Rockstopper);
   tolua_constant(tolua_S,"Stealskull",UniqueItemType::Stealskull);
   tolua_constant(tolua_S,"DarksightHelm",UniqueItemType::DarksightHelm);
   tolua_constant(tolua_S,"ValkiryWing",UniqueItemType::ValkiryWing);
   tolua_constant(tolua_S,"CrownofThieves",UniqueItemType::CrownofThieves);
   tolua_constant(tolua_S,"BlackhornsFace",UniqueItemType::BlackhornsFace);
   tolua_constant(tolua_S,"Vampiregaze",UniqueItemType::Vampiregaze);
   tolua_constant(tolua_S,"TheSpiritShroud",UniqueItemType::TheSpiritShroud);
   tolua_constant(tolua_S,"SkinoftheVipermagi",UniqueItemType::SkinoftheVipermagi);
   tolua_constant(tolua_S,"SkinoftheFlayerdOne",UniqueItemType::SkinoftheFlayerdOne);
   tolua_constant(tolua_S,"Ironpelt",UniqueItemType::Ironpelt);
   tolua_constant(tolua_S,"Spiritforge",UniqueItemType::Spiritforge);
   tolua_constant(tolua_S,"CrowCaw",UniqueItemType::CrowCaw);
   tolua_constant(tolua_S,"Shaftstop",UniqueItemType::Shaftstop);
   tolua_constant(tolua_S,"DurielsShell",UniqueItemType::DurielsShell);
   tolua_constant(tolua_S,"SkulldersIre",UniqueItemType::SkulldersIre);
   tolua_constant(tolua_S,"GuardianAngel",UniqueItemType::GuardianAngel);
   tolua_constant(tolua_S,"Toothrow",UniqueItemType::Toothrow);
   tolua_constant(tolua_S,"AtmasWail",UniqueItemType::AtmasWail);
   tolua_constant(tolua_S,"BlackHades",UniqueItemType::BlackHades);
   tolua_constant(tolua_S,"Corpsemourn",UniqueItemType::Corpsemourn);
   tolua_constant(tolua_S,"QueHegansWisdon",UniqueItemType::QueHegansWisdon);
   tolua_constant(tolua_S,"Visceratuant",UniqueItemType::Visceratuant);
   tolua_constant(tolua_S,"MosersBlessedCircle",UniqueItemType::MosersBlessedCircle);
   tolua_constant(tolua_S,"Stormchaser",UniqueItemType::Stormchaser);
   tolua_constant(tolua_S,"TiamatsRebuke",UniqueItemType::TiamatsRebuke);
   tolua_constant(tolua_S,"KerkesSanctuary",UniqueItemType::KerkesSanctuary);
   tolua_constant(tolua_S,"RadimantsSphere",UniqueItemType::RadimantsSphere);
   tolua_constant(tolua_S,"LidlessWall",UniqueItemType::LidlessWall);
   tolua_constant(tolua_S,"LanceGuard",UniqueItemType::LanceGuard);
   tolua_constant(tolua_S,"VenomGrip",UniqueItemType::VenomGrip);
   tolua_constant(tolua_S,"Gravepalm",UniqueItemType::Gravepalm);
   tolua_constant(tolua_S,"Ghoulhide",UniqueItemType::Ghoulhide);
   tolua_constant(tolua_S,"Lavagout",UniqueItemType::Lavagout);
   tolua_constant(tolua_S,"Hellmouth",UniqueItemType::Hellmouth);
   tolua_constant(tolua_S,"Infernostride",UniqueItemType::Infernostride);
   tolua_constant(tolua_S,"Waterwalk",UniqueItemType::Waterwalk);
   tolua_constant(tolua_S,"Silkweave",UniqueItemType::Silkweave);
   tolua_constant(tolua_S,"Wartraveler",UniqueItemType::Wartraveler);
   tolua_constant(tolua_S,"Gorerider",UniqueItemType::Gorerider);
   tolua_constant(tolua_S,"StringofEars",UniqueItemType::StringofEars);
   tolua_constant(tolua_S,"Razortail",UniqueItemType::Razortail);
   tolua_constant(tolua_S,"Gloomstrap",UniqueItemType::Gloomstrap);
   tolua_constant(tolua_S,"Snowclash",UniqueItemType::Snowclash);
   tolua_constant(tolua_S,"ThudergodsVigor",UniqueItemType::ThudergodsVigor);
   tolua_constant(tolua_S,"EliteUniques",UniqueItemType::EliteUniques);
   tolua_constant(tolua_S,"HarlequinCrest",UniqueItemType::HarlequinCrest);
   tolua_constant(tolua_S,"VeilofSteel",UniqueItemType::VeilofSteel);
   tolua_constant(tolua_S,"TheGladiatorsBane",UniqueItemType::TheGladiatorsBane);
   tolua_constant(tolua_S,"ArkainesValor",UniqueItemType::ArkainesValor);
   tolua_constant(tolua_S,"BlackoakShield",UniqueItemType::BlackoakShield);
   tolua_constant(tolua_S,"Stormshield",UniqueItemType::Stormshield);
   tolua_constant(tolua_S,"Hellslayer",UniqueItemType::Hellslayer);
   tolua_constant(tolua_S,"MesserschmidtsReaver",UniqueItemType::MesserschmidtsReaver);
   tolua_constant(tolua_S,"BaranarsStar",UniqueItemType::BaranarsStar);
   tolua_constant(tolua_S,"SchaefersHammer",UniqueItemType::SchaefersHammer);
   tolua_constant(tolua_S,"TheCraniumBasher",UniqueItemType::TheCraniumBasher);
   tolua_constant(tolua_S,"Lightsabre",UniqueItemType::Lightsabre);
   tolua_constant(tolua_S,"Doombringer",UniqueItemType::Doombringer);
   tolua_constant(tolua_S,"TheGrandfather",UniqueItemType::TheGrandfather);
   tolua_constant(tolua_S,"Wizardspike",UniqueItemType::Wizardspike);
   tolua_constant(tolua_S,"ConstrictingRing",UniqueItemType::ConstrictingRing);
   tolua_constant(tolua_S,"Stormspire",UniqueItemType::Stormspire);
   tolua_constant(tolua_S,"Eaglehorn",UniqueItemType::Eaglehorn);
   tolua_constant(tolua_S,"Windforce",UniqueItemType::Windforce);
   tolua_constant(tolua_S,"Rings",UniqueItemType::Rings);
   tolua_constant(tolua_S,"BulKathosWeddingBand",UniqueItemType::BulKathosWeddingBand);
   tolua_constant(tolua_S,"TheCatsEye",UniqueItemType::TheCatsEye);
   tolua_constant(tolua_S,"TheRisingSun",UniqueItemType::TheRisingSun);
   tolua_constant(tolua_S,"CrescentMoon",UniqueItemType::CrescentMoon);
   tolua_constant(tolua_S,"MarasKaleidoscope",UniqueItemType::MarasKaleidoscope);
   tolua_constant(tolua_S,"AtmasScarab",UniqueItemType::AtmasScarab);
   tolua_constant(tolua_S,"DwarfStar",UniqueItemType::DwarfStar);
   tolua_constant(tolua_S,"RavenFrost",UniqueItemType::RavenFrost);
   tolua_constant(tolua_S,"HighlordsWrath",UniqueItemType::HighlordsWrath);
   tolua_constant(tolua_S,"SaracensChance",UniqueItemType::SaracensChance);
   tolua_constant(tolua_S,"ClassSpecific",UniqueItemType::ClassSpecific);
   tolua_constant(tolua_S,"ArreatsFace",UniqueItemType::ArreatsFace);
   tolua_constant(tolua_S,"Homunculus",UniqueItemType::Homunculus);
   tolua_constant(tolua_S,"TitansRevenge",UniqueItemType::TitansRevenge);
   tolua_constant(tolua_S,"LycandersAim",UniqueItemType::LycandersAim);
   tolua_constant(tolua_S,"LycandersFlank",UniqueItemType::LycandersFlank);
   tolua_constant(tolua_S,"TheOculus",UniqueItemType::TheOculus);
   tolua_constant(tolua_S,"HeraldofZakarum",UniqueItemType::HeraldofZakarum);
   tolua_constant(tolua_S,"Cutthroat1",UniqueItemType::Cutthroat1);
   tolua_constant(tolua_S,"JalalsMane",UniqueItemType::JalalsMane);
   tolua_constant(tolua_S,"TheScalper",UniqueItemType::TheScalper);
   tolua_constant(tolua_S,"Bloodmoon",UniqueItemType::Bloodmoon);
   tolua_constant(tolua_S,"Djinnslayer",UniqueItemType::Djinnslayer);
   tolua_constant(tolua_S,"Deathbit",UniqueItemType::Deathbit);
   tolua_constant(tolua_S,"Warshrike",UniqueItemType::Warshrike);
   tolua_constant(tolua_S,"Gutsiphon",UniqueItemType::Gutsiphon);
   tolua_constant(tolua_S,"Razoredge",UniqueItemType::Razoredge);
   tolua_constant(tolua_S,"GoreRipper",UniqueItemType::GoreRipper);
   tolua_constant(tolua_S,"Demonlimb",UniqueItemType::Demonlimb);
   tolua_constant(tolua_S,"Steelshade",UniqueItemType::Steelshade);
   tolua_constant(tolua_S,"TombReaver",UniqueItemType::TombReaver);
   tolua_constant(tolua_S,"DeathssWeb",UniqueItemType::DeathssWeb);
   tolua_constant(tolua_S,"NaturesPeace",UniqueItemType::NaturesPeace);
   tolua_constant(tolua_S,"Azurewrath",UniqueItemType::Azurewrath);
   tolua_constant(tolua_S,"SeraphsHymn",UniqueItemType::SeraphsHymn);
   tolua_constant(tolua_S,"ZakarumsSalvation",UniqueItemType::ZakarumsSalvation);
   tolua_constant(tolua_S,"Fleshripper",UniqueItemType::Fleshripper);
   tolua_constant(tolua_S,"Odium",UniqueItemType::Odium);
   tolua_constant(tolua_S,"HorizonsTornado",UniqueItemType::HorizonsTornado);
   tolua_constant(tolua_S,"StoneCrusher",UniqueItemType::StoneCrusher);
   tolua_constant(tolua_S,"Jadetalon",UniqueItemType::Jadetalon);
   tolua_constant(tolua_S,"Shadowdancer",UniqueItemType::Shadowdancer);
   tolua_constant(tolua_S,"Cerebus",UniqueItemType::Cerebus);
   tolua_constant(tolua_S,"TyraelsMight",UniqueItemType::TyraelsMight);
   tolua_constant(tolua_S,"Souldrain",UniqueItemType::Souldrain);
   tolua_constant(tolua_S,"Runemaster",UniqueItemType::Runemaster);
   tolua_constant(tolua_S,"Deathcleaver",UniqueItemType::Deathcleaver);
   tolua_constant(tolua_S,"ExecutionersJustice",UniqueItemType::ExecutionersJustice);
   tolua_constant(tolua_S,"Stoneraven",UniqueItemType::Stoneraven);
   tolua_constant(tolua_S,"Leviathan",UniqueItemType::Leviathan);
   tolua_constant(tolua_S,"LarzuksChampion",UniqueItemType::LarzuksChampion);
   tolua_constant(tolua_S,"Wisp",UniqueItemType::Wisp);
   tolua_constant(tolua_S,"GargoylesBite",UniqueItemType::GargoylesBite);
   tolua_constant(tolua_S,"Lacerator",UniqueItemType::Lacerator);
   tolua_constant(tolua_S,"MangSongsLesson",UniqueItemType::MangSongsLesson);
   tolua_constant(tolua_S,"Viperfork",UniqueItemType::Viperfork);
   tolua_constant(tolua_S,"EtherealEdge",UniqueItemType::EtherealEdge);
   tolua_constant(tolua_S,"DemonhornsEdge",UniqueItemType::DemonhornsEdge);
   tolua_constant(tolua_S,"TheReapersToll",UniqueItemType::TheReapersToll);
   tolua_constant(tolua_S,"Spiritkeeper",UniqueItemType::Spiritkeeper);
   tolua_constant(tolua_S,"Hellrack",UniqueItemType::Hellrack);
   tolua_constant(tolua_S,"AlmaNegra",UniqueItemType::AlmaNegra);
   tolua_constant(tolua_S,"DarkforgeSpawn",UniqueItemType::DarkforgeSpawn);
   tolua_constant(tolua_S,"Widowmaker",UniqueItemType::Widowmaker);
   tolua_constant(tolua_S,"BloodravensCharge",UniqueItemType::BloodravensCharge);
   tolua_constant(tolua_S,"Ghostflame",UniqueItemType::Ghostflame);
   tolua_constant(tolua_S,"Shadowkiller",UniqueItemType::Shadowkiller);
   tolua_constant(tolua_S,"Gimmershred",UniqueItemType::Gimmershred);
   tolua_constant(tolua_S,"GriffonsEye",UniqueItemType::GriffonsEye);
   tolua_constant(tolua_S,"Windhammer",UniqueItemType::Windhammer);
   tolua_constant(tolua_S,"Thunderstroke",UniqueItemType::Thunderstroke);
   tolua_constant(tolua_S,"Giantmaimer",UniqueItemType::Giantmaimer);
   tolua_constant(tolua_S,"DemonsArch",UniqueItemType::DemonsArch);
   tolua_constant(tolua_S,"Boneflame",UniqueItemType::Boneflame);
   tolua_constant(tolua_S,"Steelpillar",UniqueItemType::Steelpillar);
   tolua_constant(tolua_S,"NightwingsVeil",UniqueItemType::NightwingsVeil);
   tolua_constant(tolua_S,"CrownofAges",UniqueItemType::CrownofAges);
   tolua_constant(tolua_S,"AndarielsVisage",UniqueItemType::AndarielsVisage);
   tolua_constant(tolua_S,"Darkfear",UniqueItemType::Darkfear);
   tolua_constant(tolua_S,"Dragonscale",UniqueItemType::Dragonscale);
   tolua_constant(tolua_S,"SteelCarapice",UniqueItemType::SteelCarapice);
   tolua_constant(tolua_S,"MedusasGaze",UniqueItemType::MedusasGaze);
   tolua_constant(tolua_S,"Ravenlore",UniqueItemType::Ravenlore);
   tolua_constant(tolua_S,"Boneshade",UniqueItemType::Boneshade);
   tolua_constant(tolua_S,"Nethercrow",UniqueItemType::Nethercrow);
   tolua_constant(tolua_S,"Flamebellow",UniqueItemType::Flamebellow);
   tolua_constant(tolua_S,"Fathom",UniqueItemType::Fathom);
   tolua_constant(tolua_S,"Wolfhowl",UniqueItemType::Wolfhowl);
   tolua_constant(tolua_S,"SpiritWard",UniqueItemType::SpiritWard);
   tolua_constant(tolua_S,"KirasGuardian",UniqueItemType::KirasGuardian);
   tolua_constant(tolua_S,"OrmusRobes",UniqueItemType::OrmusRobes);
   tolua_constant(tolua_S,"GheedsFortune",UniqueItemType::GheedsFortune);
   tolua_constant(tolua_S,"Stormlash",UniqueItemType::Stormlash);
   tolua_constant(tolua_S,"HalaberdsReign",UniqueItemType::HalaberdsReign);
   tolua_constant(tolua_S,"WarrivsWarder",UniqueItemType::WarrivsWarder);
   tolua_constant(tolua_S,"SpikeThorn",UniqueItemType::SpikeThorn);
   tolua_constant(tolua_S,"DraculsGrasp",UniqueItemType::DraculsGrasp);
   tolua_constant(tolua_S,"Frostwind",UniqueItemType::Frostwind);
   tolua_constant(tolua_S,"TemplarsMight",UniqueItemType::TemplarsMight);
   tolua_constant(tolua_S,"Eschutastemper",UniqueItemType::Eschutastemper);
   tolua_constant(tolua_S,"FirelizardsTalons",UniqueItemType::FirelizardsTalons);
   tolua_constant(tolua_S,"SandstormTrek",UniqueItemType::SandstormTrek);
   tolua_constant(tolua_S,"Marrowwalk",UniqueItemType::Marrowwalk);
   tolua_constant(tolua_S,"HeavensLight",UniqueItemType::HeavensLight);
   tolua_constant(tolua_S,"MermansSpeed",UniqueItemType::MermansSpeed);
   tolua_constant(tolua_S,"ArachnidMesh",UniqueItemType::ArachnidMesh);
   tolua_constant(tolua_S,"NosferatusCoil",UniqueItemType::NosferatusCoil);
   tolua_constant(tolua_S,"Metalgrid",UniqueItemType::Metalgrid);
   tolua_constant(tolua_S,"VerdugosHeartyCord",UniqueItemType::VerdugosHeartyCord);
   tolua_constant(tolua_S,"SigurdsStaunch",UniqueItemType::SigurdsStaunch);
   tolua_constant(tolua_S,"CarrionWind",UniqueItemType::CarrionWind);
   tolua_constant(tolua_S,"Giantskull",UniqueItemType::Giantskull);
   tolua_constant(tolua_S,"Ironward",UniqueItemType::Ironward);
   tolua_constant(tolua_S,"Annihilus",UniqueItemType::Annihilus);
   tolua_constant(tolua_S,"AriocsNeedle",UniqueItemType::AriocsNeedle);
   tolua_constant(tolua_S,"Cranebeak",UniqueItemType::Cranebeak);
   tolua_constant(tolua_S,"NordsTenderizer",UniqueItemType::NordsTenderizer);
   tolua_constant(tolua_S,"Earthshifter",UniqueItemType::Earthshifter);
   tolua_constant(tolua_S,"Wraithflight",UniqueItemType::Wraithflight);
   tolua_constant(tolua_S,"Bonehew",UniqueItemType::Bonehew);
   tolua_constant(tolua_S,"OndalsWisdom",UniqueItemType::OndalsWisdom);
   tolua_constant(tolua_S,"TheReedeemer",UniqueItemType::TheReedeemer);
   tolua_constant(tolua_S,"HeadhuntersGlory",UniqueItemType::HeadhuntersGlory);
   tolua_constant(tolua_S,"Steelrend",UniqueItemType::Steelrend);
   tolua_constant(tolua_S,"RainbowFacet",UniqueItemType::RainbowFacet);
   tolua_constant(tolua_S,"rainbowfacet1",UniqueItemType::rainbowfacet1);
   tolua_constant(tolua_S,"rainbowfacet2",UniqueItemType::rainbowfacet2);
   tolua_constant(tolua_S,"rainbowfacet3",UniqueItemType::rainbowfacet3);
   tolua_constant(tolua_S,"rainbowfacet4",UniqueItemType::rainbowfacet4);
   tolua_constant(tolua_S,"rainbowfacet5",UniqueItemType::rainbowfacet5);
   tolua_constant(tolua_S,"rainbowfacet6",UniqueItemType::rainbowfacet6);
   tolua_constant(tolua_S,"rainbowfacet7",UniqueItemType::rainbowfacet7);
   tolua_constant(tolua_S,"HellfireTorch",UniqueItemType::HellfireTorch);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"RunewordType",0);
  tolua_beginmodule(tolua_S,"RunewordType");
   tolua_constant(tolua_S,"Invalid",RunewordType::Invalid);
   tolua_constant(tolua_S,"AncientsPledge",RunewordType::AncientsPledge);
   tolua_constant(tolua_S,"Armageddon",RunewordType::Armageddon);
   tolua_constant(tolua_S,"Authority",RunewordType::Authority);
   tolua_constant(tolua_S,"Beast",RunewordType::Beast);
   tolua_constant(tolua_S,"Beauty",RunewordType::Beauty);
   tolua_constant(tolua_S,"Black",RunewordType::Black);
   tolua_constant(tolua_S,"Blood",RunewordType::Blood);
   tolua_constant(tolua_S,"Bone",RunewordType::Bone);
   tolua_constant(tolua_S,"Bramble",RunewordType::Bramble);
   tolua_constant(tolua_S,"Brand",RunewordType::Brand);
   tolua_constant(tolua_S,"BreathOfTheDying",RunewordType::BreathOfTheDying);
   tolua_constant(tolua_S,"BrokenPromise",RunewordType::BrokenPromise);
   tolua_constant(tolua_S,"CallToArms",RunewordType::CallToArms);
   tolua_constant(tolua_S,"ChainsOfHonor",RunewordType::ChainsOfHonor);
   tolua_constant(tolua_S,"Chance",RunewordType::Chance);
   tolua_constant(tolua_S,"Chaos",RunewordType::Chaos);
   tolua_constant(tolua_S,"CrescentMoon",RunewordType::CrescentMoon);
   tolua_constant(tolua_S,"Darkness",RunewordType::Darkness);
   tolua_constant(tolua_S,"Daylight",RunewordType::Daylight);
   tolua_constant(tolua_S,"Death",RunewordType::Death);
   tolua_constant(tolua_S,"Deception",RunewordType::Deception);
   tolua_constant(tolua_S,"Delirium",RunewordType::Delirium);
   tolua_constant(tolua_S,"Desire",RunewordType::Desire);
   tolua_constant(tolua_S,"Despair",RunewordType::Despair);
   tolua_constant(tolua_S,"Destruction",RunewordType::Destruction);
   tolua_constant(tolua_S,"Doom",RunewordType::Doom);
   tolua_constant(tolua_S,"Dragon",RunewordType::Dragon);
   tolua_constant(tolua_S,"Dread",RunewordType::Dread);
   tolua_constant(tolua_S,"Dream",RunewordType::Dream);
   tolua_constant(tolua_S,"Duress",RunewordType::Duress);
   tolua_constant(tolua_S,"Edge",RunewordType::Edge);
   tolua_constant(tolua_S,"Elation",RunewordType::Elation);
   tolua_constant(tolua_S,"Enigma",RunewordType::Enigma);
   tolua_constant(tolua_S,"Enlightenment",RunewordType::Enlightenment);
   tolua_constant(tolua_S,"Envy",RunewordType::Envy);
   tolua_constant(tolua_S,"Eternity",RunewordType::Eternity);
   tolua_constant(tolua_S,"Exile",RunewordType::Exile);
   tolua_constant(tolua_S,"Faith",RunewordType::Faith);
   tolua_constant(tolua_S,"Famine",RunewordType::Famine);
   tolua_constant(tolua_S,"Flame",RunewordType::Flame);
   tolua_constant(tolua_S,"Fortitude",RunewordType::Fortitude);
   tolua_constant(tolua_S,"Fortune",RunewordType::Fortune);
   tolua_constant(tolua_S,"Friendship",RunewordType::Friendship);
   tolua_constant(tolua_S,"Fury",RunewordType::Fury);
   tolua_constant(tolua_S,"Gloom",RunewordType::Gloom);
   tolua_constant(tolua_S,"Glory",RunewordType::Glory);
   tolua_constant(tolua_S,"Grief",RunewordType::Grief);
   tolua_constant(tolua_S,"HandOfJustice",RunewordType::HandOfJustice);
   tolua_constant(tolua_S,"Harmony",RunewordType::Harmony);
   tolua_constant(tolua_S,"Hatred",RunewordType::Hatred);
   tolua_constant(tolua_S,"HeartOfTheOak",RunewordType::HeartOfTheOak);
   tolua_constant(tolua_S,"HeavensWill",RunewordType::HeavensWill);
   tolua_constant(tolua_S,"HolyTears",RunewordType::HolyTears);
   tolua_constant(tolua_S,"HolyThunder",RunewordType::HolyThunder);
   tolua_constant(tolua_S,"Honor",RunewordType::Honor);
   tolua_constant(tolua_S,"Revenge",RunewordType::Revenge);
   tolua_constant(tolua_S,"Humility",RunewordType::Humility);
   tolua_constant(tolua_S,"Hunger",RunewordType::Hunger);
   tolua_constant(tolua_S,"Ice",RunewordType::Ice);
   tolua_constant(tolua_S,"Infinity",RunewordType::Infinity);
   tolua_constant(tolua_S,"Innocence",RunewordType::Innocence);
   tolua_constant(tolua_S,"Insight",RunewordType::Insight);
   tolua_constant(tolua_S,"Jealousy",RunewordType::Jealousy);
   tolua_constant(tolua_S,"Judgement",RunewordType::Judgement);
   tolua_constant(tolua_S,"KingsGrace",RunewordType::KingsGrace);
   tolua_constant(tolua_S,"Kingslayer",RunewordType::Kingslayer);
   tolua_constant(tolua_S,"KnightsVigil",RunewordType::KnightsVigil);
   tolua_constant(tolua_S,"Knowledge",RunewordType::Knowledge);
   tolua_constant(tolua_S,"LastWish",RunewordType::LastWish);
   tolua_constant(tolua_S,"Law",RunewordType::Law);
   tolua_constant(tolua_S,"Lawbringer",RunewordType::Lawbringer);
   tolua_constant(tolua_S,"Leaf",RunewordType::Leaf);
   tolua_constant(tolua_S,"Lightning",RunewordType::Lightning);
   tolua_constant(tolua_S,"Lionheart",RunewordType::Lionheart);
   tolua_constant(tolua_S,"Lore",RunewordType::Lore);
   tolua_constant(tolua_S,"Love",RunewordType::Love);
   tolua_constant(tolua_S,"Loyalty",RunewordType::Loyalty);
   tolua_constant(tolua_S,"Lust",RunewordType::Lust);
   tolua_constant(tolua_S,"Madness",RunewordType::Madness);
   tolua_constant(tolua_S,"Runeword80",RunewordType::Runeword80);
   tolua_constant(tolua_S,"Malice",RunewordType::Malice);
   tolua_constant(tolua_S,"Melody",RunewordType::Melody);
   tolua_constant(tolua_S,"Memory",RunewordType::Memory);
   tolua_constant(tolua_S,"Mist",RunewordType::Mist);
   tolua_constant(tolua_S,"Morning",RunewordType::Morning);
   tolua_constant(tolua_S,"Mystery",RunewordType::Mystery);
   tolua_constant(tolua_S,"Myth",RunewordType::Myth);
   tolua_constant(tolua_S,"Nadir",RunewordType::Nadir);
   tolua_constant(tolua_S,"NaturesKingdom",RunewordType::NaturesKingdom);
   tolua_constant(tolua_S,"Night",RunewordType::Night);
   tolua_constant(tolua_S,"Oath",RunewordType::Oath);
   tolua_constant(tolua_S,"Obedience",RunewordType::Obedience);
   tolua_constant(tolua_S,"Oblivion",RunewordType::Oblivion);
   tolua_constant(tolua_S,"Obsession",RunewordType::Obsession);
   tolua_constant(tolua_S,"Passion",RunewordType::Passion);
   tolua_constant(tolua_S,"Patience",RunewordType::Patience);
   tolua_constant(tolua_S,"Pattern",RunewordType::Pattern);
   tolua_constant(tolua_S,"Peace",RunewordType::Peace);
   tolua_constant(tolua_S,"VoiceOfReason",RunewordType::VoiceOfReason);
   tolua_constant(tolua_S,"Penitence",RunewordType::Penitence);
   tolua_constant(tolua_S,"Peril",RunewordType::Peril);
   tolua_constant(tolua_S,"Pestilence",RunewordType::Pestilence);
   tolua_constant(tolua_S,"Phoenix",RunewordType::Phoenix);
   tolua_constant(tolua_S,"Piety",RunewordType::Piety);
   tolua_constant(tolua_S,"PillarOfFaith",RunewordType::PillarOfFaith);
   tolua_constant(tolua_S,"Plague",RunewordType::Plague);
   tolua_constant(tolua_S,"Praise",RunewordType::Praise);
   tolua_constant(tolua_S,"Prayer",RunewordType::Prayer);
   tolua_constant(tolua_S,"Pride",RunewordType::Pride);
   tolua_constant(tolua_S,"Principle",RunewordType::Principle);
   tolua_constant(tolua_S,"ProwessInBattle",RunewordType::ProwessInBattle);
   tolua_constant(tolua_S,"Prudence",RunewordType::Prudence);
   tolua_constant(tolua_S,"Punishment",RunewordType::Punishment);
   tolua_constant(tolua_S,"Purity",RunewordType::Purity);
   tolua_constant(tolua_S,"Question",RunewordType::Question);
   tolua_constant(tolua_S,"Radiance",RunewordType::Radiance);
   tolua_constant(tolua_S,"Rain",RunewordType::Rain);
   tolua_constant(tolua_S,"Reason",RunewordType::Reason);
   tolua_constant(tolua_S,"Red",RunewordType::Red);
   tolua_constant(tolua_S,"Rhyme",RunewordType::Rhyme);
   tolua_constant(tolua_S,"Rift",RunewordType::Rift);
   tolua_constant(tolua_S,"Sanctuary",RunewordType::Sanctuary);
   tolua_constant(tolua_S,"Serendipity",RunewordType::Serendipity);
   tolua_constant(tolua_S,"Shadow",RunewordType::Shadow);
   tolua_constant(tolua_S,"ShadowOfDoubt",RunewordType::ShadowOfDoubt);
   tolua_constant(tolua_S,"Silence",RunewordType::Silence);
   tolua_constant(tolua_S,"SirensSong",RunewordType::SirensSong);
   tolua_constant(tolua_S,"Smoke",RunewordType::Smoke);
   tolua_constant(tolua_S,"Sorrow",RunewordType::Sorrow);
   tolua_constant(tolua_S,"Spirit",RunewordType::Spirit);
   tolua_constant(tolua_S,"Splendor",RunewordType::Splendor);
   tolua_constant(tolua_S,"Starlight",RunewordType::Starlight);
   tolua_constant(tolua_S,"Stealth",RunewordType::Stealth);
   tolua_constant(tolua_S,"Steel",RunewordType::Steel);
   tolua_constant(tolua_S,"StillWater",RunewordType::StillWater);
   tolua_constant(tolua_S,"Sting",RunewordType::Sting);
   tolua_constant(tolua_S,"Stone",RunewordType::Stone);
   tolua_constant(tolua_S,"Storm",RunewordType::Storm);
   tolua_constant(tolua_S,"Strength",RunewordType::Strength);
   tolua_constant(tolua_S,"Tempest",RunewordType::Tempest);
   tolua_constant(tolua_S,"Temptation",RunewordType::Temptation);
   tolua_constant(tolua_S,"Terror",RunewordType::Terror);
   tolua_constant(tolua_S,"Thirst",RunewordType::Thirst);
   tolua_constant(tolua_S,"Thought",RunewordType::Thought);
   tolua_constant(tolua_S,"Thunder",RunewordType::Thunder);
   tolua_constant(tolua_S,"Time",RunewordType::Time);
   tolua_constant(tolua_S,"Tradition",RunewordType::Tradition);
   tolua_constant(tolua_S,"Treachery",RunewordType::Treachery);
   tolua_constant(tolua_S,"Trust",RunewordType::Trust);
   tolua_constant(tolua_S,"Truth",RunewordType::Truth);
   tolua_constant(tolua_S,"UnbendingWill",RunewordType::UnbendingWill);
   tolua_constant(tolua_S,"Valor",RunewordType::Valor);
   tolua_constant(tolua_S,"Vengeance",RunewordType::Vengeance);
   tolua_constant(tolua_S,"Venom",RunewordType::Venom);
   tolua_constant(tolua_S,"Victory",RunewordType::Victory);
   tolua_constant(tolua_S,"Voice",RunewordType::Voice);
   tolua_constant(tolua_S,"Void",RunewordType::Void);
   tolua_constant(tolua_S,"War",RunewordType::War);
   tolua_constant(tolua_S,"Water",RunewordType::Water);
   tolua_constant(tolua_S,"Wealth",RunewordType::Wealth);
   tolua_constant(tolua_S,"Whisper",RunewordType::Whisper);
   tolua_constant(tolua_S,"White",RunewordType::White);
   tolua_constant(tolua_S,"Wind",RunewordType::Wind);
   tolua_constant(tolua_S,"WingsOfHope",RunewordType::WingsOfHope);
   tolua_constant(tolua_S,"Wisdom",RunewordType::Wisdom);
   tolua_constant(tolua_S,"Woe",RunewordType::Woe);
   tolua_constant(tolua_S,"Wonder",RunewordType::Wonder);
   tolua_constant(tolua_S,"Wrath",RunewordType::Wrath);
   tolua_constant(tolua_S,"Youth",RunewordType::Youth);
   tolua_constant(tolua_S,"Zephyr",RunewordType::Zephyr);
   tolua_constant(tolua_S,"Unknown",RunewordType::Unknown);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"MagicPrefixType",0);
  tolua_beginmodule(tolua_S,"MagicPrefixType");
   tolua_constant(tolua_S,"None",MagicPrefixType::None);
   tolua_constant(tolua_S,"Unused1",MagicPrefixType::Unused1);
   tolua_constant(tolua_S,"Sturdy",MagicPrefixType::Sturdy);
   tolua_constant(tolua_S,"Strong",MagicPrefixType::Strong);
   tolua_constant(tolua_S,"Glorious",MagicPrefixType::Glorious);
   tolua_constant(tolua_S,"Blessed",MagicPrefixType::Blessed);
   tolua_constant(tolua_S,"Saintly",MagicPrefixType::Saintly);
   tolua_constant(tolua_S,"Holy",MagicPrefixType::Holy);
   tolua_constant(tolua_S,"Devious",MagicPrefixType::Devious);
   tolua_constant(tolua_S,"Fortified",MagicPrefixType::Fortified);
   tolua_constant(tolua_S,"Unused10",MagicPrefixType::Unused10);
   tolua_constant(tolua_S,"Unused11",MagicPrefixType::Unused11);
   tolua_constant(tolua_S,"Unused12",MagicPrefixType::Unused12);
   tolua_constant(tolua_S,"Jagged6",MagicPrefixType::Jagged6);
   tolua_constant(tolua_S,"Deadly",MagicPrefixType::Deadly);
   tolua_constant(tolua_S,"Vicious",MagicPrefixType::Vicious);
   tolua_constant(tolua_S,"Brutal",MagicPrefixType::Brutal);
   tolua_constant(tolua_S,"Massive",MagicPrefixType::Massive);
   tolua_constant(tolua_S,"Savage",MagicPrefixType::Savage);
   tolua_constant(tolua_S,"Merciless",MagicPrefixType::Merciless);
   tolua_constant(tolua_S,"Vulpine",MagicPrefixType::Vulpine);
   tolua_constant(tolua_S,"Unused21",MagicPrefixType::Unused21);
   tolua_constant(tolua_S,"Unused22",MagicPrefixType::Unused22);
   tolua_constant(tolua_S,"Unused23",MagicPrefixType::Unused23);
   tolua_constant(tolua_S,"Unused24",MagicPrefixType::Unused24);
   tolua_constant(tolua_S,"Tireless",MagicPrefixType::Tireless);
   tolua_constant(tolua_S,"Rugged",MagicPrefixType::Rugged);
   tolua_constant(tolua_S,"Bronze",MagicPrefixType::Bronze);
   tolua_constant(tolua_S,"Iron",MagicPrefixType::Iron);
   tolua_constant(tolua_S,"Steel",MagicPrefixType::Steel);
   tolua_constant(tolua_S,"Silver",MagicPrefixType::Silver);
   tolua_constant(tolua_S,"Unused31",MagicPrefixType::Unused31);
   tolua_constant(tolua_S,"Gold",MagicPrefixType::Gold);
   tolua_constant(tolua_S,"Platinum",MagicPrefixType::Platinum);
   tolua_constant(tolua_S,"Meteoric",MagicPrefixType::Meteoric);
   tolua_constant(tolua_S,"Sharp",MagicPrefixType::Sharp);
   tolua_constant(tolua_S,"Fine",MagicPrefixType::Fine);
   tolua_constant(tolua_S,"Warriors",MagicPrefixType::Warriors);
   tolua_constant(tolua_S,"Soldiers",MagicPrefixType::Soldiers);
   tolua_constant(tolua_S,"Knights",MagicPrefixType::Knights);
   tolua_constant(tolua_S,"Lords",MagicPrefixType::Lords);
   tolua_constant(tolua_S,"Kings",MagicPrefixType::Kings);
   tolua_constant(tolua_S,"Howling",MagicPrefixType::Howling);
   tolua_constant(tolua_S,"Fortuitous",MagicPrefixType::Fortuitous);
   tolua_constant(tolua_S,"Unused44",MagicPrefixType::Unused44);
   tolua_constant(tolua_S,"Unused45",MagicPrefixType::Unused45);
   tolua_constant(tolua_S,"Unused46",MagicPrefixType::Unused46);
   tolua_constant(tolua_S,"Unused47",MagicPrefixType::Unused47);
   tolua_constant(tolua_S,"Unused48",MagicPrefixType::Unused48);
   tolua_constant(tolua_S,"Glimmering",MagicPrefixType::Glimmering);
   tolua_constant(tolua_S,"Glowing7",MagicPrefixType::Glowing7);
   tolua_constant(tolua_S,"Unused51",MagicPrefixType::Unused51);
   tolua_constant(tolua_S,"Unused52",MagicPrefixType::Unused52);
   tolua_constant(tolua_S,"Lizards",MagicPrefixType::Lizards);
   tolua_constant(tolua_S,"Unused54",MagicPrefixType::Unused54);
   tolua_constant(tolua_S,"Snakes",MagicPrefixType::Snakes);
   tolua_constant(tolua_S,"Serpents",MagicPrefixType::Serpents);
   tolua_constant(tolua_S,"Serpents2",MagicPrefixType::Serpents2);
   tolua_constant(tolua_S,"Drakes",MagicPrefixType::Drakes);
   tolua_constant(tolua_S,"Dragons",MagicPrefixType::Dragons);
   tolua_constant(tolua_S,"Dragons2",MagicPrefixType::Dragons2);
   tolua_constant(tolua_S,"Wyrms",MagicPrefixType::Wyrms);
   tolua_constant(tolua_S,"Unused62",MagicPrefixType::Unused62);
   tolua_constant(tolua_S,"Unused63",MagicPrefixType::Unused63);
   tolua_constant(tolua_S,"Prismatic",MagicPrefixType::Prismatic);
   tolua_constant(tolua_S,"Prismatic2",MagicPrefixType::Prismatic2);
   tolua_constant(tolua_S,"Azure",MagicPrefixType::Azure);
   tolua_constant(tolua_S,"Lapis",MagicPrefixType::Lapis);
   tolua_constant(tolua_S,"Lapis2",MagicPrefixType::Lapis2);
   tolua_constant(tolua_S,"Cobalt",MagicPrefixType::Cobalt);
   tolua_constant(tolua_S,"Cobalt2",MagicPrefixType::Cobalt2);
   tolua_constant(tolua_S,"Unused71",MagicPrefixType::Unused71);
   tolua_constant(tolua_S,"Sapphire",MagicPrefixType::Sapphire);
   tolua_constant(tolua_S,"Unused73",MagicPrefixType::Unused73);
   tolua_constant(tolua_S,"Unused74",MagicPrefixType::Unused74);
   tolua_constant(tolua_S,"Crimson",MagicPrefixType::Crimson);
   tolua_constant(tolua_S,"Burgundy",MagicPrefixType::Burgundy);
   tolua_constant(tolua_S,"Burgundy2",MagicPrefixType::Burgundy2);
   tolua_constant(tolua_S,"Garnet",MagicPrefixType::Garnet);
   tolua_constant(tolua_S,"Garnet2",MagicPrefixType::Garnet2);
   tolua_constant(tolua_S,"Unused80",MagicPrefixType::Unused80);
   tolua_constant(tolua_S,"Ruby",MagicPrefixType::Ruby);
   tolua_constant(tolua_S,"Unused82",MagicPrefixType::Unused82);
   tolua_constant(tolua_S,"Unused83",MagicPrefixType::Unused83);
   tolua_constant(tolua_S,"Ocher",MagicPrefixType::Ocher);
   tolua_constant(tolua_S,"Tangerine",MagicPrefixType::Tangerine);
   tolua_constant(tolua_S,"Tangerine2",MagicPrefixType::Tangerine2);
   tolua_constant(tolua_S,"Coral",MagicPrefixType::Coral);
   tolua_constant(tolua_S,"Coral2",MagicPrefixType::Coral2);
   tolua_constant(tolua_S,"Unused89",MagicPrefixType::Unused89);
   tolua_constant(tolua_S,"Amber",MagicPrefixType::Amber);
   tolua_constant(tolua_S,"Unused91",MagicPrefixType::Unused91);
   tolua_constant(tolua_S,"Unused92",MagicPrefixType::Unused92);
   tolua_constant(tolua_S,"Beryl",MagicPrefixType::Beryl);
   tolua_constant(tolua_S,"Jade",MagicPrefixType::Jade);
   tolua_constant(tolua_S,"Jade2",MagicPrefixType::Jade2);
   tolua_constant(tolua_S,"Viridian",MagicPrefixType::Viridian);
   tolua_constant(tolua_S,"Viridian2",MagicPrefixType::Viridian2);
   tolua_constant(tolua_S,"Unused98",MagicPrefixType::Unused98);
   tolua_constant(tolua_S,"Emerald",MagicPrefixType::Emerald);
   tolua_constant(tolua_S,"Unused100",MagicPrefixType::Unused100);
   tolua_constant(tolua_S,"Fletchers",MagicPrefixType::Fletchers);
   tolua_constant(tolua_S,"Archers",MagicPrefixType::Archers);
   tolua_constant(tolua_S,"Archers2",MagicPrefixType::Archers2);
   tolua_constant(tolua_S,"Monks",MagicPrefixType::Monks);
   tolua_constant(tolua_S,"Priests",MagicPrefixType::Priests);
   tolua_constant(tolua_S,"Priests2",MagicPrefixType::Priests2);
   tolua_constant(tolua_S,"Summoners",MagicPrefixType::Summoners);
   tolua_constant(tolua_S,"Necromancers",MagicPrefixType::Necromancers);
   tolua_constant(tolua_S,"Necromancers2",MagicPrefixType::Necromancers2);
   tolua_constant(tolua_S,"Angels",MagicPrefixType::Angels);
   tolua_constant(tolua_S,"Arch",MagicPrefixType::Arch);
   tolua_constant(tolua_S,"Arch2",MagicPrefixType::Arch2);
   tolua_constant(tolua_S,"Slayers",MagicPrefixType::Slayers);
   tolua_constant(tolua_S,"Berserkers",MagicPrefixType::Berserkers);
   tolua_constant(tolua_S,"Berserkers2",MagicPrefixType::Berserkers2);
   tolua_constant(tolua_S,"Unused116",MagicPrefixType::Unused116);
   tolua_constant(tolua_S,"Unused117",MagicPrefixType::Unused117);
   tolua_constant(tolua_S,"Triumphant",MagicPrefixType::Triumphant);
   tolua_constant(tolua_S,"Stout",MagicPrefixType::Stout);
   tolua_constant(tolua_S,"Stout2",MagicPrefixType::Stout2);
   tolua_constant(tolua_S,"Stout3",MagicPrefixType::Stout3);
   tolua_constant(tolua_S,"Burly",MagicPrefixType::Burly);
   tolua_constant(tolua_S,"Burly2",MagicPrefixType::Burly2);
   tolua_constant(tolua_S,"Burly3",MagicPrefixType::Burly3);
   tolua_constant(tolua_S,"Stalwart",MagicPrefixType::Stalwart);
   tolua_constant(tolua_S,"Stalwart2",MagicPrefixType::Stalwart2);
   tolua_constant(tolua_S,"Stalwart3",MagicPrefixType::Stalwart3);
   tolua_constant(tolua_S,"Stout4",MagicPrefixType::Stout4);
   tolua_constant(tolua_S,"Stout5",MagicPrefixType::Stout5);
   tolua_constant(tolua_S,"Stout6",MagicPrefixType::Stout6);
   tolua_constant(tolua_S,"Burly4",MagicPrefixType::Burly4);
   tolua_constant(tolua_S,"Burly5",MagicPrefixType::Burly5);
   tolua_constant(tolua_S,"Stalwart4",MagicPrefixType::Stalwart4);
   tolua_constant(tolua_S,"Stalwart5",MagicPrefixType::Stalwart5);
   tolua_constant(tolua_S,"Stout7",MagicPrefixType::Stout7);
   tolua_constant(tolua_S,"Stout8",MagicPrefixType::Stout8);
   tolua_constant(tolua_S,"Burly6",MagicPrefixType::Burly6);
   tolua_constant(tolua_S,"Stalwart6",MagicPrefixType::Stalwart6);
   tolua_constant(tolua_S,"Blanched",MagicPrefixType::Blanched);
   tolua_constant(tolua_S,"Eburin",MagicPrefixType::Eburin);
   tolua_constant(tolua_S,"Bone",MagicPrefixType::Bone);
   tolua_constant(tolua_S,"Ivory",MagicPrefixType::Ivory);
   tolua_constant(tolua_S,"Sturdy2",MagicPrefixType::Sturdy2);
   tolua_constant(tolua_S,"Sturdy3",MagicPrefixType::Sturdy3);
   tolua_constant(tolua_S,"Strong2",MagicPrefixType::Strong2);
   tolua_constant(tolua_S,"Glorious2",MagicPrefixType::Glorious2);
   tolua_constant(tolua_S,"Blessed2",MagicPrefixType::Blessed2);
   tolua_constant(tolua_S,"Saintly2",MagicPrefixType::Saintly2);
   tolua_constant(tolua_S,"Holy2",MagicPrefixType::Holy2);
   tolua_constant(tolua_S,"Godly",MagicPrefixType::Godly);
   tolua_constant(tolua_S,"Unused151",MagicPrefixType::Unused151);
   tolua_constant(tolua_S,"Unused152",MagicPrefixType::Unused152);
   tolua_constant(tolua_S,"Unused153",MagicPrefixType::Unused153);
   tolua_constant(tolua_S,"Unused154",MagicPrefixType::Unused154);
   tolua_constant(tolua_S,"Unused155",MagicPrefixType::Unused155);
   tolua_constant(tolua_S,"Unused156",MagicPrefixType::Unused156);
   tolua_constant(tolua_S,"Unused157",MagicPrefixType::Unused157);
   tolua_constant(tolua_S,"Unused158",MagicPrefixType::Unused158);
   tolua_constant(tolua_S,"Unused159",MagicPrefixType::Unused159);
   tolua_constant(tolua_S,"Unused160",MagicPrefixType::Unused160);
   tolua_constant(tolua_S,"Unused161",MagicPrefixType::Unused161);
   tolua_constant(tolua_S,"Unused162",MagicPrefixType::Unused162);
   tolua_constant(tolua_S,"Unused163",MagicPrefixType::Unused163);
   tolua_constant(tolua_S,"Unused164",MagicPrefixType::Unused164);
   tolua_constant(tolua_S,"Unused165",MagicPrefixType::Unused165);
   tolua_constant(tolua_S,"Scarlet",MagicPrefixType::Scarlet);
   tolua_constant(tolua_S,"Crimson2",MagicPrefixType::Crimson2);
   tolua_constant(tolua_S,"Unused168",MagicPrefixType::Unused168);
   tolua_constant(tolua_S,"Unused169",MagicPrefixType::Unused169);
   tolua_constant(tolua_S,"Unused170",MagicPrefixType::Unused170);
   tolua_constant(tolua_S,"Unused171",MagicPrefixType::Unused171);
   tolua_constant(tolua_S,"Unused172",MagicPrefixType::Unused172);
   tolua_constant(tolua_S,"Unused173",MagicPrefixType::Unused173);
   tolua_constant(tolua_S,"Unused174",MagicPrefixType::Unused174);
   tolua_constant(tolua_S,"Unused175",MagicPrefixType::Unused175);
   tolua_constant(tolua_S,"Unused176",MagicPrefixType::Unused176);
   tolua_constant(tolua_S,"Unused177",MagicPrefixType::Unused177);
   tolua_constant(tolua_S,"Unused178",MagicPrefixType::Unused178);
   tolua_constant(tolua_S,"Unused179",MagicPrefixType::Unused179);
   tolua_constant(tolua_S,"Unused180",MagicPrefixType::Unused180);
   tolua_constant(tolua_S,"Unused181",MagicPrefixType::Unused181);
   tolua_constant(tolua_S,"Unused182",MagicPrefixType::Unused182);
   tolua_constant(tolua_S,"Carbuncle",MagicPrefixType::Carbuncle);
   tolua_constant(tolua_S,"Carmine",MagicPrefixType::Carmine);
   tolua_constant(tolua_S,"Vermillion",MagicPrefixType::Vermillion);
   tolua_constant(tolua_S,"Jagged2",MagicPrefixType::Jagged2);
   tolua_constant(tolua_S,"Deadly2",MagicPrefixType::Deadly2);
   tolua_constant(tolua_S,"Vicious2",MagicPrefixType::Vicious2);
   tolua_constant(tolua_S,"Brutal2",MagicPrefixType::Brutal2);
   tolua_constant(tolua_S,"Massive2",MagicPrefixType::Massive2);
   tolua_constant(tolua_S,"Savage2",MagicPrefixType::Savage2);
   tolua_constant(tolua_S,"Merciless2",MagicPrefixType::Merciless2);
   tolua_constant(tolua_S,"Ferocious",MagicPrefixType::Ferocious);
   tolua_constant(tolua_S,"Cruel",MagicPrefixType::Cruel);
   tolua_constant(tolua_S,"Cinnabar",MagicPrefixType::Cinnabar);
   tolua_constant(tolua_S,"Rusty",MagicPrefixType::Rusty);
   tolua_constant(tolua_S,"Realgar",MagicPrefixType::Realgar);
   tolua_constant(tolua_S,"Ruby2",MagicPrefixType::Ruby2);
   tolua_constant(tolua_S,"Vulpine2",MagicPrefixType::Vulpine2);
   tolua_constant(tolua_S,"Dun",MagicPrefixType::Dun);
   tolua_constant(tolua_S,"Tireless2",MagicPrefixType::Tireless2);
   tolua_constant(tolua_S,"Tireless3",MagicPrefixType::Tireless3);
   tolua_constant(tolua_S,"Brown",MagicPrefixType::Brown);
   tolua_constant(tolua_S,"Rugged2",MagicPrefixType::Rugged2);
   tolua_constant(tolua_S,"Rugged3",MagicPrefixType::Rugged3);
   tolua_constant(tolua_S,"Rugged4",MagicPrefixType::Rugged4);
   tolua_constant(tolua_S,"Rugged5",MagicPrefixType::Rugged5);
   tolua_constant(tolua_S,"Rugged6",MagicPrefixType::Rugged6);
   tolua_constant(tolua_S,"Rugged7",MagicPrefixType::Rugged7);
   tolua_constant(tolua_S,"Rugged8",MagicPrefixType::Rugged8);
   tolua_constant(tolua_S,"Rugged9",MagicPrefixType::Rugged9);
   tolua_constant(tolua_S,"Rugged10",MagicPrefixType::Rugged10);
   tolua_constant(tolua_S,"Rugged11",MagicPrefixType::Rugged11);
   tolua_constant(tolua_S,"Rugged12",MagicPrefixType::Rugged12);
   tolua_constant(tolua_S,"Vigorous",MagicPrefixType::Vigorous);
   tolua_constant(tolua_S,"Chestnut",MagicPrefixType::Chestnut);
   tolua_constant(tolua_S,"Maroon",MagicPrefixType::Maroon);
   tolua_constant(tolua_S,"Bronze2",MagicPrefixType::Bronze2);
   tolua_constant(tolua_S,"Bronze3",MagicPrefixType::Bronze3);
   tolua_constant(tolua_S,"Bronze4",MagicPrefixType::Bronze4);
   tolua_constant(tolua_S,"Iron2",MagicPrefixType::Iron2);
   tolua_constant(tolua_S,"Iron3",MagicPrefixType::Iron3);
   tolua_constant(tolua_S,"Iron4",MagicPrefixType::Iron4);
   tolua_constant(tolua_S,"Steel2",MagicPrefixType::Steel2);
   tolua_constant(tolua_S,"Steel3",MagicPrefixType::Steel3);
   tolua_constant(tolua_S,"Steel4",MagicPrefixType::Steel4);
   tolua_constant(tolua_S,"Bronze5",MagicPrefixType::Bronze5);
   tolua_constant(tolua_S,"Bronze6",MagicPrefixType::Bronze6);
   tolua_constant(tolua_S,"Bronze7",MagicPrefixType::Bronze7);
   tolua_constant(tolua_S,"Iron5",MagicPrefixType::Iron5);
   tolua_constant(tolua_S,"Iron6",MagicPrefixType::Iron6);
   tolua_constant(tolua_S,"Steel5",MagicPrefixType::Steel5);
   tolua_constant(tolua_S,"Steel6",MagicPrefixType::Steel6);
   tolua_constant(tolua_S,"Bronze8",MagicPrefixType::Bronze8);
   tolua_constant(tolua_S,"Bronze9",MagicPrefixType::Bronze9);
   tolua_constant(tolua_S,"Iron7",MagicPrefixType::Iron7);
   tolua_constant(tolua_S,"Steel7",MagicPrefixType::Steel7);
   tolua_constant(tolua_S,"Bronze10",MagicPrefixType::Bronze10);
   tolua_constant(tolua_S,"Iron8",MagicPrefixType::Iron8);
   tolua_constant(tolua_S,"Steel8",MagicPrefixType::Steel8);
   tolua_constant(tolua_S,"Silver2",MagicPrefixType::Silver2);
   tolua_constant(tolua_S,"Gold2",MagicPrefixType::Gold2);
   tolua_constant(tolua_S,"Platinum2",MagicPrefixType::Platinum2);
   tolua_constant(tolua_S,"Meteoric2",MagicPrefixType::Meteoric2);
   tolua_constant(tolua_S,"Strange",MagicPrefixType::Strange);
   tolua_constant(tolua_S,"Weird",MagicPrefixType::Weird);
   tolua_constant(tolua_S,"Nickel",MagicPrefixType::Nickel);
   tolua_constant(tolua_S,"Tin",MagicPrefixType::Tin);
   tolua_constant(tolua_S,"Silver3",MagicPrefixType::Silver3);
   tolua_constant(tolua_S,"Argent",MagicPrefixType::Argent);
   tolua_constant(tolua_S,"Fine2",MagicPrefixType::Fine2);
   tolua_constant(tolua_S,"Fine3",MagicPrefixType::Fine3);
   tolua_constant(tolua_S,"Sharp2",MagicPrefixType::Sharp2);
   tolua_constant(tolua_S,"Fine4",MagicPrefixType::Fine4);
   tolua_constant(tolua_S,"Sharp3",MagicPrefixType::Sharp3);
   tolua_constant(tolua_S,"Fine5",MagicPrefixType::Fine5);
   tolua_constant(tolua_S,"Sharp4",MagicPrefixType::Sharp4);
   tolua_constant(tolua_S,"Fine6",MagicPrefixType::Fine6);
   tolua_constant(tolua_S,"Warriors2",MagicPrefixType::Warriors2);
   tolua_constant(tolua_S,"Soldiers2",MagicPrefixType::Soldiers2);
   tolua_constant(tolua_S,"Knights2",MagicPrefixType::Knights2);
   tolua_constant(tolua_S,"Lords2",MagicPrefixType::Lords2);
   tolua_constant(tolua_S,"Kings2",MagicPrefixType::Kings2);
   tolua_constant(tolua_S,"Masters",MagicPrefixType::Masters);
   tolua_constant(tolua_S,"Grandmasters",MagicPrefixType::Grandmasters);
   tolua_constant(tolua_S,"Glimmering2",MagicPrefixType::Glimmering2);
   tolua_constant(tolua_S,"Glowing2",MagicPrefixType::Glowing2);
   tolua_constant(tolua_S,"Bright",MagicPrefixType::Bright);
   tolua_constant(tolua_S,"Screaming",MagicPrefixType::Screaming);
   tolua_constant(tolua_S,"Howling2",MagicPrefixType::Howling2);
   tolua_constant(tolua_S,"Wailing",MagicPrefixType::Wailing);
   tolua_constant(tolua_S,"Screaming2",MagicPrefixType::Screaming2);
   tolua_constant(tolua_S,"Howling3",MagicPrefixType::Howling3);
   tolua_constant(tolua_S,"Wailing2",MagicPrefixType::Wailing2);
   tolua_constant(tolua_S,"Lucky",MagicPrefixType::Lucky);
   tolua_constant(tolua_S,"Lucky2",MagicPrefixType::Lucky2);
   tolua_constant(tolua_S,"Lucky3",MagicPrefixType::Lucky3);
   tolua_constant(tolua_S,"Lucky4",MagicPrefixType::Lucky4);
   tolua_constant(tolua_S,"Lucky5",MagicPrefixType::Lucky5);
   tolua_constant(tolua_S,"Lucky6",MagicPrefixType::Lucky6);
   tolua_constant(tolua_S,"Felicitous",MagicPrefixType::Felicitous);
   tolua_constant(tolua_S,"Fortuitous2",MagicPrefixType::Fortuitous2);
   tolua_constant(tolua_S,"Emerald2",MagicPrefixType::Emerald2);
   tolua_constant(tolua_S,"Lizards3",MagicPrefixType::Lizards3);
   tolua_constant(tolua_S,"Lizards4",MagicPrefixType::Lizards4);
   tolua_constant(tolua_S,"Lizards5",MagicPrefixType::Lizards5);
   tolua_constant(tolua_S,"Snakes2",MagicPrefixType::Snakes2);
   tolua_constant(tolua_S,"Snakes3",MagicPrefixType::Snakes3);
   tolua_constant(tolua_S,"Snakes4",MagicPrefixType::Snakes4);
   tolua_constant(tolua_S,"Serpents3",MagicPrefixType::Serpents3);
   tolua_constant(tolua_S,"Serpents4",MagicPrefixType::Serpents4);
   tolua_constant(tolua_S,"Serpents5",MagicPrefixType::Serpents5);
   tolua_constant(tolua_S,"Lizards6",MagicPrefixType::Lizards6);
   tolua_constant(tolua_S,"Lizards7",MagicPrefixType::Lizards7);
   tolua_constant(tolua_S,"Lizards8",MagicPrefixType::Lizards8);
   tolua_constant(tolua_S,"Snakes5",MagicPrefixType::Snakes5);
   tolua_constant(tolua_S,"Snakes6",MagicPrefixType::Snakes6);
   tolua_constant(tolua_S,"Serpents6",MagicPrefixType::Serpents6);
   tolua_constant(tolua_S,"Serpents7",MagicPrefixType::Serpents7);
   tolua_constant(tolua_S,"Lizards9",MagicPrefixType::Lizards9);
   tolua_constant(tolua_S,"Lizards10",MagicPrefixType::Lizards10);
   tolua_constant(tolua_S,"Snakes7",MagicPrefixType::Snakes7);
   tolua_constant(tolua_S,"Serpents8",MagicPrefixType::Serpents8);
   tolua_constant(tolua_S,"Lizards11",MagicPrefixType::Lizards11);
   tolua_constant(tolua_S,"Snakes8",MagicPrefixType::Snakes8);
   tolua_constant(tolua_S,"Serpents9",MagicPrefixType::Serpents9);
   tolua_constant(tolua_S,"Serpents10",MagicPrefixType::Serpents10);
   tolua_constant(tolua_S,"Drakes2",MagicPrefixType::Drakes2);
   tolua_constant(tolua_S,"Dragons3",MagicPrefixType::Dragons3);
   tolua_constant(tolua_S,"Dragons4",MagicPrefixType::Dragons4);
   tolua_constant(tolua_S,"Wyrms2",MagicPrefixType::Wyrms2);
   tolua_constant(tolua_S,"Great",MagicPrefixType::Great);
   tolua_constant(tolua_S,"Bahamuts",MagicPrefixType::Bahamuts);
   tolua_constant(tolua_S,"Zircon",MagicPrefixType::Zircon);
   tolua_constant(tolua_S,"Jacinth",MagicPrefixType::Jacinth);
   tolua_constant(tolua_S,"Turquoise",MagicPrefixType::Turquoise);
   tolua_constant(tolua_S,"Shimmering",MagicPrefixType::Shimmering);
   tolua_constant(tolua_S,"Shimmering2",MagicPrefixType::Shimmering2);
   tolua_constant(tolua_S,"Shimmering3",MagicPrefixType::Shimmering3);
   tolua_constant(tolua_S,"Shimmering4",MagicPrefixType::Shimmering4);
   tolua_constant(tolua_S,"Shimmering5",MagicPrefixType::Shimmering5);
   tolua_constant(tolua_S,"Shimmering6",MagicPrefixType::Shimmering6);
   tolua_constant(tolua_S,"Shimmering7",MagicPrefixType::Shimmering7);
   tolua_constant(tolua_S,"Rainbow",MagicPrefixType::Rainbow);
   tolua_constant(tolua_S,"Scintillating",MagicPrefixType::Scintillating);
   tolua_constant(tolua_S,"Prismatic3",MagicPrefixType::Prismatic3);
   tolua_constant(tolua_S,"Chromatic",MagicPrefixType::Chromatic);
   tolua_constant(tolua_S,"Shimmering8",MagicPrefixType::Shimmering8);
   tolua_constant(tolua_S,"Rainbow2",MagicPrefixType::Rainbow2);
   tolua_constant(tolua_S,"Scintillating2",MagicPrefixType::Scintillating2);
   tolua_constant(tolua_S,"Prismatic4",MagicPrefixType::Prismatic4);
   tolua_constant(tolua_S,"Chromatic2",MagicPrefixType::Chromatic2);
   tolua_constant(tolua_S,"Shimmering9",MagicPrefixType::Shimmering9);
   tolua_constant(tolua_S,"Rainbow3",MagicPrefixType::Rainbow3);
   tolua_constant(tolua_S,"Scintillating3",MagicPrefixType::Scintillating3);
   tolua_constant(tolua_S,"Shimmering10",MagicPrefixType::Shimmering10);
   tolua_constant(tolua_S,"Scintillating4",MagicPrefixType::Scintillating4);
   tolua_constant(tolua_S,"Azure2",MagicPrefixType::Azure2);
   tolua_constant(tolua_S,"Lapis3",MagicPrefixType::Lapis3);
   tolua_constant(tolua_S,"Cobalt3",MagicPrefixType::Cobalt3);
   tolua_constant(tolua_S,"Sapphire2",MagicPrefixType::Sapphire2);
   tolua_constant(tolua_S,"Azure3",MagicPrefixType::Azure3);
   tolua_constant(tolua_S,"Lapis4",MagicPrefixType::Lapis4);
   tolua_constant(tolua_S,"Cobalt4",MagicPrefixType::Cobalt4);
   tolua_constant(tolua_S,"Sapphire3",MagicPrefixType::Sapphire3);
   tolua_constant(tolua_S,"Azure4",MagicPrefixType::Azure4);
   tolua_constant(tolua_S,"Lapis5",MagicPrefixType::Lapis5);
   tolua_constant(tolua_S,"Cobalt5",MagicPrefixType::Cobalt5);
   tolua_constant(tolua_S,"Sapphire4",MagicPrefixType::Sapphire4);
   tolua_constant(tolua_S,"Azure5",MagicPrefixType::Azure5);
   tolua_constant(tolua_S,"Lapis6",MagicPrefixType::Lapis6);
   tolua_constant(tolua_S,"Lapis7",MagicPrefixType::Lapis7);
   tolua_constant(tolua_S,"Cobalt6",MagicPrefixType::Cobalt6);
   tolua_constant(tolua_S,"Cobalt7",MagicPrefixType::Cobalt7);
   tolua_constant(tolua_S,"Sapphire5",MagicPrefixType::Sapphire5);
   tolua_constant(tolua_S,"Lapis8",MagicPrefixType::Lapis8);
   tolua_constant(tolua_S,"Sapphire6",MagicPrefixType::Sapphire6);
   tolua_constant(tolua_S,"Crimson3",MagicPrefixType::Crimson3);
   tolua_constant(tolua_S,"Russet",MagicPrefixType::Russet);
   tolua_constant(tolua_S,"Garnet3",MagicPrefixType::Garnet3);
   tolua_constant(tolua_S,"Ruby3",MagicPrefixType::Ruby3);
   tolua_constant(tolua_S,"Crimson4",MagicPrefixType::Crimson4);
   tolua_constant(tolua_S,"Russet2",MagicPrefixType::Russet2);
   tolua_constant(tolua_S,"Garnet4",MagicPrefixType::Garnet4);
   tolua_constant(tolua_S,"Ruby4",MagicPrefixType::Ruby4);
   tolua_constant(tolua_S,"Crimson5",MagicPrefixType::Crimson5);
   tolua_constant(tolua_S,"Russet5",MagicPrefixType::Russet5);
   tolua_constant(tolua_S,"Garnet5",MagicPrefixType::Garnet5);
   tolua_constant(tolua_S,"Ruby5",MagicPrefixType::Ruby5);
   tolua_constant(tolua_S,"Russet6",MagicPrefixType::Russet6);
   tolua_constant(tolua_S,"Russet7",MagicPrefixType::Russet7);
   tolua_constant(tolua_S,"Garnet6",MagicPrefixType::Garnet6);
   tolua_constant(tolua_S,"Garnet7",MagicPrefixType::Garnet7);
   tolua_constant(tolua_S,"Ruby6",MagicPrefixType::Ruby6);
   tolua_constant(tolua_S,"Garnet8",MagicPrefixType::Garnet8);
   tolua_constant(tolua_S,"Ruby7",MagicPrefixType::Ruby7);
   tolua_constant(tolua_S,"Tangerine3",MagicPrefixType::Tangerine3);
   tolua_constant(tolua_S,"Ocher2",MagicPrefixType::Ocher2);
   tolua_constant(tolua_S,"Coral3",MagicPrefixType::Coral3);
   tolua_constant(tolua_S,"Amber2",MagicPrefixType::Amber2);
   tolua_constant(tolua_S,"Tangerine4",MagicPrefixType::Tangerine4);
   tolua_constant(tolua_S,"Ocher3",MagicPrefixType::Ocher3);
   tolua_constant(tolua_S,"Coral4",MagicPrefixType::Coral4);
   tolua_constant(tolua_S,"Amber3",MagicPrefixType::Amber3);
   tolua_constant(tolua_S,"Tangerine5",MagicPrefixType::Tangerine5);
   tolua_constant(tolua_S,"Ocher4",MagicPrefixType::Ocher4);
   tolua_constant(tolua_S,"Coral5",MagicPrefixType::Coral5);
   tolua_constant(tolua_S,"Amber4",MagicPrefixType::Amber4);
   tolua_constant(tolua_S,"Tangerine6",MagicPrefixType::Tangerine6);
   tolua_constant(tolua_S,"Ocher5",MagicPrefixType::Ocher5);
   tolua_constant(tolua_S,"Ocher6",MagicPrefixType::Ocher6);
   tolua_constant(tolua_S,"Coral6",MagicPrefixType::Coral6);
   tolua_constant(tolua_S,"Coral7",MagicPrefixType::Coral7);
   tolua_constant(tolua_S,"Amber5",MagicPrefixType::Amber5);
   tolua_constant(tolua_S,"Camphor",MagicPrefixType::Camphor);
   tolua_constant(tolua_S,"Ambergris",MagicPrefixType::Ambergris);
   tolua_constant(tolua_S,"Beryl2",MagicPrefixType::Beryl2);
   tolua_constant(tolua_S,"Viridian3",MagicPrefixType::Viridian3);
   tolua_constant(tolua_S,"Jade3",MagicPrefixType::Jade3);
   tolua_constant(tolua_S,"Emerald3",MagicPrefixType::Emerald3);
   tolua_constant(tolua_S,"Beryl3",MagicPrefixType::Beryl3);
   tolua_constant(tolua_S,"Viridian4",MagicPrefixType::Viridian4);
   tolua_constant(tolua_S,"Jade4",MagicPrefixType::Jade4);
   tolua_constant(tolua_S,"Emerald4",MagicPrefixType::Emerald4);
   tolua_constant(tolua_S,"Beryl4",MagicPrefixType::Beryl4);
   tolua_constant(tolua_S,"Viridian5",MagicPrefixType::Viridian5);
   tolua_constant(tolua_S,"Jade5",MagicPrefixType::Jade5);
   tolua_constant(tolua_S,"Emerald5",MagicPrefixType::Emerald5);
   tolua_constant(tolua_S,"Beryl5",MagicPrefixType::Beryl5);
   tolua_constant(tolua_S,"Viridian6",MagicPrefixType::Viridian6);
   tolua_constant(tolua_S,"Viridian7",MagicPrefixType::Viridian7);
   tolua_constant(tolua_S,"Jade6",MagicPrefixType::Jade6);
   tolua_constant(tolua_S,"Jade7",MagicPrefixType::Jade7);
   tolua_constant(tolua_S,"Emerald6",MagicPrefixType::Emerald6);
   tolua_constant(tolua_S,"Beryl6",MagicPrefixType::Beryl6);
   tolua_constant(tolua_S,"Jade8",MagicPrefixType::Jade8);
   tolua_constant(tolua_S,"Triumphant2",MagicPrefixType::Triumphant2);
   tolua_constant(tolua_S,"Victorious",MagicPrefixType::Victorious);
   tolua_constant(tolua_S,"Aureolin",MagicPrefixType::Aureolin);
   tolua_constant(tolua_S,"Mechanists",MagicPrefixType::Mechanists);
   tolua_constant(tolua_S,"Artificers",MagicPrefixType::Artificers);
   tolua_constant(tolua_S,"Jewelers",MagicPrefixType::Jewelers);
   tolua_constant(tolua_S,"Assamic",MagicPrefixType::Assamic);
   tolua_constant(tolua_S,"Arcadian",MagicPrefixType::Arcadian);
   tolua_constant(tolua_S,"Unearthly",MagicPrefixType::Unearthly);
   tolua_constant(tolua_S,"Astral",MagicPrefixType::Astral);
   tolua_constant(tolua_S,"Elysian",MagicPrefixType::Elysian);
   tolua_constant(tolua_S,"Celestial",MagicPrefixType::Celestial);
   tolua_constant(tolua_S,"Diamond",MagicPrefixType::Diamond);
   tolua_constant(tolua_S,"Fletchers2",MagicPrefixType::Fletchers2);
   tolua_constant(tolua_S,"Acrobats",MagicPrefixType::Acrobats);
   tolua_constant(tolua_S,"Harpoonists",MagicPrefixType::Harpoonists);
   tolua_constant(tolua_S,"Fletchers3",MagicPrefixType::Fletchers3);
   tolua_constant(tolua_S,"Bowyers",MagicPrefixType::Bowyers);
   tolua_constant(tolua_S,"Archers3",MagicPrefixType::Archers3);
   tolua_constant(tolua_S,"Acrobats2",MagicPrefixType::Acrobats2);
   tolua_constant(tolua_S,"Gymnasts",MagicPrefixType::Gymnasts);
   tolua_constant(tolua_S,"Athletes",MagicPrefixType::Athletes);
   tolua_constant(tolua_S,"Harpoonists2",MagicPrefixType::Harpoonists2);
   tolua_constant(tolua_S,"Spearmaidens",MagicPrefixType::Spearmaidens);
   tolua_constant(tolua_S,"Lancers",MagicPrefixType::Lancers);
   tolua_constant(tolua_S,"Burning",MagicPrefixType::Burning);
   tolua_constant(tolua_S,"Sparking",MagicPrefixType::Sparking);
   tolua_constant(tolua_S,"Chilling",MagicPrefixType::Chilling);
   tolua_constant(tolua_S,"Burning2",MagicPrefixType::Burning2);
   tolua_constant(tolua_S,"Blazing",MagicPrefixType::Blazing);
   tolua_constant(tolua_S,"Volcanic",MagicPrefixType::Volcanic);
   tolua_constant(tolua_S,"Sparking2",MagicPrefixType::Sparking2);
   tolua_constant(tolua_S,"Charged",MagicPrefixType::Charged);
   tolua_constant(tolua_S,"Powered",MagicPrefixType::Powered);
   tolua_constant(tolua_S,"Chilling2",MagicPrefixType::Chilling2);
   tolua_constant(tolua_S,"Freezing",MagicPrefixType::Freezing);
   tolua_constant(tolua_S,"Glacial",MagicPrefixType::Glacial);
   tolua_constant(tolua_S,"Hexing",MagicPrefixType::Hexing);
   tolua_constant(tolua_S,"Fungal",MagicPrefixType::Fungal);
   tolua_constant(tolua_S,"Graverobbers",MagicPrefixType::Graverobbers);
   tolua_constant(tolua_S,"Hexing2",MagicPrefixType::Hexing2);
   tolua_constant(tolua_S,"Blighting",MagicPrefixType::Blighting);
   tolua_constant(tolua_S,"Accursed",MagicPrefixType::Accursed);
   tolua_constant(tolua_S,"Fungal2",MagicPrefixType::Fungal2);
   tolua_constant(tolua_S,"Noxious",MagicPrefixType::Noxious);
   tolua_constant(tolua_S,"Venomous",MagicPrefixType::Venomous);
   tolua_constant(tolua_S,"Graverobbers2",MagicPrefixType::Graverobbers2);
   tolua_constant(tolua_S,"Vodoun",MagicPrefixType::Vodoun);
   tolua_constant(tolua_S,"Golemlords",MagicPrefixType::Golemlords);
   tolua_constant(tolua_S,"Lion",MagicPrefixType::Lion);
   tolua_constant(tolua_S,"Captains",MagicPrefixType::Captains);
   tolua_constant(tolua_S,"Preservers",MagicPrefixType::Preservers);
   tolua_constant(tolua_S,"Lion2",MagicPrefixType::Lion2);
   tolua_constant(tolua_S,"Hawk",MagicPrefixType::Hawk);
   tolua_constant(tolua_S,"Rose",MagicPrefixType::Rose);
   tolua_constant(tolua_S,"Captains2",MagicPrefixType::Captains2);
   tolua_constant(tolua_S,"Commanders",MagicPrefixType::Commanders);
   tolua_constant(tolua_S,"Marshals",MagicPrefixType::Marshals);
   tolua_constant(tolua_S,"Preservers2",MagicPrefixType::Preservers2);
   tolua_constant(tolua_S,"Warders",MagicPrefixType::Warders);
   tolua_constant(tolua_S,"Guardians",MagicPrefixType::Guardians);
   tolua_constant(tolua_S,"Experts",MagicPrefixType::Experts);
   tolua_constant(tolua_S,"Fanatic",MagicPrefixType::Fanatic);
   tolua_constant(tolua_S,"Sounding",MagicPrefixType::Sounding);
   tolua_constant(tolua_S,"Experts2",MagicPrefixType::Experts2);
   tolua_constant(tolua_S,"Veterans",MagicPrefixType::Veterans);
   tolua_constant(tolua_S,"Masters2",MagicPrefixType::Masters2);
   tolua_constant(tolua_S,"Fanatic2",MagicPrefixType::Fanatic2);
   tolua_constant(tolua_S,"Raging",MagicPrefixType::Raging);
   tolua_constant(tolua_S,"Furious",MagicPrefixType::Furious);
   tolua_constant(tolua_S,"Sounding2",MagicPrefixType::Sounding2);
   tolua_constant(tolua_S,"Resonant",MagicPrefixType::Resonant);
   tolua_constant(tolua_S,"Echoing",MagicPrefixType::Echoing);
   tolua_constant(tolua_S,"Trainers",MagicPrefixType::Trainers);
   tolua_constant(tolua_S,"Spiritual",MagicPrefixType::Spiritual);
   tolua_constant(tolua_S,"Natures",MagicPrefixType::Natures);
   tolua_constant(tolua_S,"Trainers2",MagicPrefixType::Trainers2);
   tolua_constant(tolua_S,"Caretakers",MagicPrefixType::Caretakers);
   tolua_constant(tolua_S,"Keepers",MagicPrefixType::Keepers);
   tolua_constant(tolua_S,"Spiritual2",MagicPrefixType::Spiritual2);
   tolua_constant(tolua_S,"Feral",MagicPrefixType::Feral);
   tolua_constant(tolua_S,"Communal",MagicPrefixType::Communal);
   tolua_constant(tolua_S,"Natures2",MagicPrefixType::Natures2);
   tolua_constant(tolua_S,"Terras",MagicPrefixType::Terras);
   tolua_constant(tolua_S,"Gaeas",MagicPrefixType::Gaeas);
   tolua_constant(tolua_S,"Entrapping",MagicPrefixType::Entrapping);
   tolua_constant(tolua_S,"Mentalists",MagicPrefixType::Mentalists);
   tolua_constant(tolua_S,"Shogukushas",MagicPrefixType::Shogukushas);
   tolua_constant(tolua_S,"Entrapping2",MagicPrefixType::Entrapping2);
   tolua_constant(tolua_S,"Tricksters",MagicPrefixType::Tricksters);
   tolua_constant(tolua_S,"Cunning",MagicPrefixType::Cunning);
   tolua_constant(tolua_S,"Mentalists2",MagicPrefixType::Mentalists2);
   tolua_constant(tolua_S,"Psychic",MagicPrefixType::Psychic);
   tolua_constant(tolua_S,"Shadow",MagicPrefixType::Shadow);
   tolua_constant(tolua_S,"Shogukushas2",MagicPrefixType::Shogukushas2);
   tolua_constant(tolua_S,"Senseis",MagicPrefixType::Senseis);
   tolua_constant(tolua_S,"Kenshis",MagicPrefixType::Kenshis);
   tolua_constant(tolua_S,"Unused514",MagicPrefixType::Unused514);
   tolua_constant(tolua_S,"Unused515",MagicPrefixType::Unused515);
   tolua_constant(tolua_S,"Unused516",MagicPrefixType::Unused516);
   tolua_constant(tolua_S,"Unused517",MagicPrefixType::Unused517);
   tolua_constant(tolua_S,"Unused518",MagicPrefixType::Unused518);
   tolua_constant(tolua_S,"Unused519",MagicPrefixType::Unused519);
   tolua_constant(tolua_S,"Paleocene",MagicPrefixType::Paleocene);
   tolua_constant(tolua_S,"Paleocene2",MagicPrefixType::Paleocene2);
   tolua_constant(tolua_S,"Unused520",MagicPrefixType::Unused520);
   tolua_constant(tolua_S,"Unused521",MagicPrefixType::Unused521);
   tolua_constant(tolua_S,"Unused522",MagicPrefixType::Unused522);
   tolua_constant(tolua_S,"Unused523",MagicPrefixType::Unused523);
   tolua_constant(tolua_S,"Trump",MagicPrefixType::Trump);
   tolua_constant(tolua_S,"Unused525",MagicPrefixType::Unused525);
   tolua_constant(tolua_S,"Unused526",MagicPrefixType::Unused526);
   tolua_constant(tolua_S,"Unused527",MagicPrefixType::Unused527);
   tolua_constant(tolua_S,"Unused528",MagicPrefixType::Unused528);
   tolua_constant(tolua_S,"Gritty",MagicPrefixType::Gritty);
   tolua_constant(tolua_S,"Unused530",MagicPrefixType::Unused530);
   tolua_constant(tolua_S,"Unused531",MagicPrefixType::Unused531);
   tolua_constant(tolua_S,"Unused532",MagicPrefixType::Unused532);
   tolua_constant(tolua_S,"Unused533",MagicPrefixType::Unused533);
   tolua_constant(tolua_S,"Unused534",MagicPrefixType::Unused534);
   tolua_constant(tolua_S,"Hawkeye",MagicPrefixType::Hawkeye);
   tolua_constant(tolua_S,"Unused535",MagicPrefixType::Unused535);
   tolua_constant(tolua_S,"Visionary",MagicPrefixType::Visionary);
   tolua_constant(tolua_S,"Mnemonic",MagicPrefixType::Mnemonic);
   tolua_constant(tolua_S,"Snowflake",MagicPrefixType::Snowflake);
   tolua_constant(tolua_S,"Shivering",MagicPrefixType::Shivering);
   tolua_constant(tolua_S,"Boreal",MagicPrefixType::Boreal);
   tolua_constant(tolua_S,"Hibernal",MagicPrefixType::Hibernal);
   tolua_constant(tolua_S,"Ember",MagicPrefixType::Ember);
   tolua_constant(tolua_S,"Smoldering",MagicPrefixType::Smoldering);
   tolua_constant(tolua_S,"Smoking",MagicPrefixType::Smoking);
   tolua_constant(tolua_S,"Flaming",MagicPrefixType::Flaming);
   tolua_constant(tolua_S,"Scorching",MagicPrefixType::Scorching);
   tolua_constant(tolua_S,"Static",MagicPrefixType::Static);
   tolua_constant(tolua_S,"Glowing3",MagicPrefixType::Glowing3);
   tolua_constant(tolua_S,"Buzzing",MagicPrefixType::Buzzing);
   tolua_constant(tolua_S,"Arcing",MagicPrefixType::Arcing);
   tolua_constant(tolua_S,"Shocking",MagicPrefixType::Shocking);
   tolua_constant(tolua_S,"Septic",MagicPrefixType::Septic);
   tolua_constant(tolua_S,"Envenomed",MagicPrefixType::Envenomed);
   tolua_constant(tolua_S,"Corosive",MagicPrefixType::Corosive);
   tolua_constant(tolua_S,"Toxic",MagicPrefixType::Toxic);
   tolua_constant(tolua_S,"Pestilent",MagicPrefixType::Pestilent);
   tolua_constant(tolua_S,"Maidens",MagicPrefixType::Maidens);
   tolua_constant(tolua_S,"Valkyries",MagicPrefixType::Valkyries);
   tolua_constant(tolua_S,"Maidens2",MagicPrefixType::Maidens2);
   tolua_constant(tolua_S,"Valkyries2",MagicPrefixType::Valkyries2);
   tolua_constant(tolua_S,"Monks2",MagicPrefixType::Monks2);
   tolua_constant(tolua_S,"Priests3",MagicPrefixType::Priests3);
   tolua_constant(tolua_S,"Monks3",MagicPrefixType::Monks3);
   tolua_constant(tolua_S,"Priests4",MagicPrefixType::Priests4);
   tolua_constant(tolua_S,"Monks4",MagicPrefixType::Monks4);
   tolua_constant(tolua_S,"Priests5",MagicPrefixType::Priests5);
   tolua_constant(tolua_S,"Summoners2",MagicPrefixType::Summoners2);
   tolua_constant(tolua_S,"Necromancers3",MagicPrefixType::Necromancers3);
   tolua_constant(tolua_S,"Summoners3",MagicPrefixType::Summoners3);
   tolua_constant(tolua_S,"Necromancers4",MagicPrefixType::Necromancers4);
   tolua_constant(tolua_S,"Angels2",MagicPrefixType::Angels2);
   tolua_constant(tolua_S,"Arch3",MagicPrefixType::Arch3);
   tolua_constant(tolua_S,"Angels3",MagicPrefixType::Angels3);
   tolua_constant(tolua_S,"Arch4",MagicPrefixType::Arch4);
   tolua_constant(tolua_S,"Slayers2",MagicPrefixType::Slayers2);
   tolua_constant(tolua_S,"Berserkers3",MagicPrefixType::Berserkers3);
   tolua_constant(tolua_S,"Slayers3",MagicPrefixType::Slayers3);
   tolua_constant(tolua_S,"Berserkers4",MagicPrefixType::Berserkers4);
   tolua_constant(tolua_S,"Slayers4",MagicPrefixType::Slayers4);
   tolua_constant(tolua_S,"Berserkers5",MagicPrefixType::Berserkers5);
   tolua_constant(tolua_S,"Shamans",MagicPrefixType::Shamans);
   tolua_constant(tolua_S,"Hierophants",MagicPrefixType::Hierophants);
   tolua_constant(tolua_S,"Shamans2",MagicPrefixType::Shamans2);
   tolua_constant(tolua_S,"Hierophants2",MagicPrefixType::Hierophants2);
   tolua_constant(tolua_S,"Magekillers",MagicPrefixType::Magekillers);
   tolua_constant(tolua_S,"Witch",MagicPrefixType::Witch);
   tolua_constant(tolua_S,"Magekillers2",MagicPrefixType::Magekillers2);
   tolua_constant(tolua_S,"Witch2",MagicPrefixType::Witch2);
   tolua_constant(tolua_S,"Compact",MagicPrefixType::Compact);
   tolua_constant(tolua_S,"Thin",MagicPrefixType::Thin);
   tolua_constant(tolua_S,"Dense",MagicPrefixType::Dense);
   tolua_constant(tolua_S,"Consecrated",MagicPrefixType::Consecrated);
   tolua_constant(tolua_S,"Pure",MagicPrefixType::Pure);
   tolua_constant(tolua_S,"Sacred",MagicPrefixType::Sacred);
   tolua_constant(tolua_S,"Hallowed",MagicPrefixType::Hallowed);
   tolua_constant(tolua_S,"Divine",MagicPrefixType::Divine);
   tolua_constant(tolua_S,"Pearl",MagicPrefixType::Pearl);
   tolua_constant(tolua_S,"Crimson6",MagicPrefixType::Crimson6);
   tolua_constant(tolua_S,"Red",MagicPrefixType::Red);
   tolua_constant(tolua_S,"Sanguinary",MagicPrefixType::Sanguinary);
   tolua_constant(tolua_S,"Bloody",MagicPrefixType::Bloody);
   tolua_constant(tolua_S,"Red2",MagicPrefixType::Red2);
   tolua_constant(tolua_S,"Sanguinary2",MagicPrefixType::Sanguinary2);
   tolua_constant(tolua_S,"Red3",MagicPrefixType::Red3);
   tolua_constant(tolua_S,"Jagged3",MagicPrefixType::Jagged3);
   tolua_constant(tolua_S,"Forked",MagicPrefixType::Forked);
   tolua_constant(tolua_S,"Serrated",MagicPrefixType::Serrated);
   tolua_constant(tolua_S,"Jagged4",MagicPrefixType::Jagged4);
   tolua_constant(tolua_S,"Forked2",MagicPrefixType::Forked2);
   tolua_constant(tolua_S,"Jagged5",MagicPrefixType::Jagged5);
   tolua_constant(tolua_S,"Snowflake2",MagicPrefixType::Snowflake2);
   tolua_constant(tolua_S,"Shivering2",MagicPrefixType::Shivering2);
   tolua_constant(tolua_S,"Boreal2",MagicPrefixType::Boreal2);
   tolua_constant(tolua_S,"Hibernal2",MagicPrefixType::Hibernal2);
   tolua_constant(tolua_S,"Snowflake3",MagicPrefixType::Snowflake3);
   tolua_constant(tolua_S,"Shivering3",MagicPrefixType::Shivering3);
   tolua_constant(tolua_S,"Boreal3",MagicPrefixType::Boreal3);
   tolua_constant(tolua_S,"Hibernal3",MagicPrefixType::Hibernal3);
   tolua_constant(tolua_S,"Snowflake4",MagicPrefixType::Snowflake4);
   tolua_constant(tolua_S,"Shivering4",MagicPrefixType::Shivering4);
   tolua_constant(tolua_S,"Boreal4",MagicPrefixType::Boreal4);
   tolua_constant(tolua_S,"Hibernal4",MagicPrefixType::Hibernal4);
   tolua_constant(tolua_S,"Ember2",MagicPrefixType::Ember2);
   tolua_constant(tolua_S,"Smoldering2",MagicPrefixType::Smoldering2);
   tolua_constant(tolua_S,"Smoking2",MagicPrefixType::Smoking2);
   tolua_constant(tolua_S,"Flaming2",MagicPrefixType::Flaming2);
   tolua_constant(tolua_S,"Ember3",MagicPrefixType::Ember3);
   tolua_constant(tolua_S,"Smoldering3",MagicPrefixType::Smoldering3);
   tolua_constant(tolua_S,"Smoking3",MagicPrefixType::Smoking3);
   tolua_constant(tolua_S,"Flaming3",MagicPrefixType::Flaming3);
   tolua_constant(tolua_S,"Ember4",MagicPrefixType::Ember4);
   tolua_constant(tolua_S,"Smoldering4",MagicPrefixType::Smoldering4);
   tolua_constant(tolua_S,"Smoking4",MagicPrefixType::Smoking4);
   tolua_constant(tolua_S,"Flaming4",MagicPrefixType::Flaming4);
   tolua_constant(tolua_S,"Static2",MagicPrefixType::Static2);
   tolua_constant(tolua_S,"Glowing4",MagicPrefixType::Glowing4);
   tolua_constant(tolua_S,"Arcing2",MagicPrefixType::Arcing2);
   tolua_constant(tolua_S,"Shocking2",MagicPrefixType::Shocking2);
   tolua_constant(tolua_S,"Static3",MagicPrefixType::Static3);
   tolua_constant(tolua_S,"Glowing5",MagicPrefixType::Glowing5);
   tolua_constant(tolua_S,"Arcing3",MagicPrefixType::Arcing3);
   tolua_constant(tolua_S,"Shocking3",MagicPrefixType::Shocking3);
   tolua_constant(tolua_S,"Static4",MagicPrefixType::Static4);
   tolua_constant(tolua_S,"Glowing6",MagicPrefixType::Glowing6);
   tolua_constant(tolua_S,"Arcing4",MagicPrefixType::Arcing4);
   tolua_constant(tolua_S,"Shocking4",MagicPrefixType::Shocking4);
   tolua_constant(tolua_S,"Septic2",MagicPrefixType::Septic2);
   tolua_constant(tolua_S,"Envenomed2",MagicPrefixType::Envenomed2);
   tolua_constant(tolua_S,"Toxic2",MagicPrefixType::Toxic2);
   tolua_constant(tolua_S,"Pestilent2",MagicPrefixType::Pestilent2);
   tolua_constant(tolua_S,"Septic3",MagicPrefixType::Septic3);
   tolua_constant(tolua_S,"Envenomed3",MagicPrefixType::Envenomed3);
   tolua_constant(tolua_S,"Toxic3",MagicPrefixType::Toxic3);
   tolua_constant(tolua_S,"Pestilent3",MagicPrefixType::Pestilent3);
   tolua_constant(tolua_S,"Septic4",MagicPrefixType::Septic4);
   tolua_constant(tolua_S,"Envenomed4",MagicPrefixType::Envenomed4);
   tolua_constant(tolua_S,"Toxic4",MagicPrefixType::Toxic4);
   tolua_constant(tolua_S,"Pestilent4",MagicPrefixType::Pestilent4);
   tolua_constant(tolua_S,"Tireless4",MagicPrefixType::Tireless4);
   tolua_constant(tolua_S,"Lizards2",MagicPrefixType::Lizards2);
   tolua_constant(tolua_S,"Azure6",MagicPrefixType::Azure6);
   tolua_constant(tolua_S,"Crimson7",MagicPrefixType::Crimson7);
   tolua_constant(tolua_S,"Tangerine7",MagicPrefixType::Tangerine7);
   tolua_constant(tolua_S,"Beryl7",MagicPrefixType::Beryl7);
   tolua_constant(tolua_S,"Godly2",MagicPrefixType::Godly2);
   tolua_constant(tolua_S,"Cruel2",MagicPrefixType::Cruel2);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"MagicSuffixType",0);
  tolua_beginmodule(tolua_S,"MagicSuffixType");
   tolua_constant(tolua_S,"None",MagicSuffixType::None);
   tolua_constant(tolua_S,"Health",MagicSuffixType::Health);
   tolua_constant(tolua_S,"Protection",MagicSuffixType::Protection);
   tolua_constant(tolua_S,"Absorption",MagicSuffixType::Absorption);
   tolua_constant(tolua_S,"Life",MagicSuffixType::Life);
   tolua_constant(tolua_S,"Unused5",MagicSuffixType::Unused5);
   tolua_constant(tolua_S,"Warding",MagicSuffixType::Warding);
   tolua_constant(tolua_S,"TheSentinel",MagicSuffixType::TheSentinel);
   tolua_constant(tolua_S,"Guarding",MagicSuffixType::Guarding);
   tolua_constant(tolua_S,"Negation",MagicSuffixType::Negation);
   tolua_constant(tolua_S,"Unused10",MagicSuffixType::Unused10);
   tolua_constant(tolua_S,"Piercing",MagicSuffixType::Piercing);
   tolua_constant(tolua_S,"Bashing",MagicSuffixType::Bashing);
   tolua_constant(tolua_S,"Puncturing",MagicSuffixType::Puncturing);
   tolua_constant(tolua_S,"Thorns",MagicSuffixType::Thorns);
   tolua_constant(tolua_S,"Spikes",MagicSuffixType::Spikes);
   tolua_constant(tolua_S,"Readiness",MagicSuffixType::Readiness);
   tolua_constant(tolua_S,"Alacrity",MagicSuffixType::Alacrity);
   tolua_constant(tolua_S,"Swiftness",MagicSuffixType::Swiftness);
   tolua_constant(tolua_S,"Quickness",MagicSuffixType::Quickness);
   tolua_constant(tolua_S,"Blocking",MagicSuffixType::Blocking);
   tolua_constant(tolua_S,"Deflecting",MagicSuffixType::Deflecting);
   tolua_constant(tolua_S,"TheApprentice",MagicSuffixType::TheApprentice);
   tolua_constant(tolua_S,"TheMagus",MagicSuffixType::TheMagus);
   tolua_constant(tolua_S,"Frost",MagicSuffixType::Frost);
   tolua_constant(tolua_S,"TheGlacier",MagicSuffixType::TheGlacier);
   tolua_constant(tolua_S,"Frost2",MagicSuffixType::Frost2);
   tolua_constant(tolua_S,"Warmth3",MagicSuffixType::Warmth3);
   tolua_constant(tolua_S,"Flame",MagicSuffixType::Flame);
   tolua_constant(tolua_S,"Fire",MagicSuffixType::Fire);
   tolua_constant(tolua_S,"Burning",MagicSuffixType::Burning);
   tolua_constant(tolua_S,"Flame2",MagicSuffixType::Flame2);
   tolua_constant(tolua_S,"Shock",MagicSuffixType::Shock);
   tolua_constant(tolua_S,"Lightning",MagicSuffixType::Lightning);
   tolua_constant(tolua_S,"Thunder",MagicSuffixType::Thunder);
   tolua_constant(tolua_S,"Shock2",MagicSuffixType::Shock2);
   tolua_constant(tolua_S,"Craftsmanship",MagicSuffixType::Craftsmanship);
   tolua_constant(tolua_S,"Quality",MagicSuffixType::Quality);
   tolua_constant(tolua_S,"Maiming",MagicSuffixType::Maiming);
   tolua_constant(tolua_S,"Slaying",MagicSuffixType::Slaying);
   tolua_constant(tolua_S,"Gore",MagicSuffixType::Gore);
   tolua_constant(tolua_S,"Carnage",MagicSuffixType::Carnage);
   tolua_constant(tolua_S,"Slaughter",MagicSuffixType::Slaughter);
   tolua_constant(tolua_S,"Maiming2",MagicSuffixType::Maiming2);
   tolua_constant(tolua_S,"Worth",MagicSuffixType::Worth);
   tolua_constant(tolua_S,"Measure",MagicSuffixType::Measure);
   tolua_constant(tolua_S,"Excellence",MagicSuffixType::Excellence);
   tolua_constant(tolua_S,"Performance",MagicSuffixType::Performance);
   tolua_constant(tolua_S,"Measure2",MagicSuffixType::Measure2);
   tolua_constant(tolua_S,"Blight",MagicSuffixType::Blight);
   tolua_constant(tolua_S,"Venom",MagicSuffixType::Venom);
   tolua_constant(tolua_S,"Pestilence",MagicSuffixType::Pestilence);
   tolua_constant(tolua_S,"Blight2",MagicSuffixType::Blight2);
   tolua_constant(tolua_S,"Dexterity",MagicSuffixType::Dexterity);
   tolua_constant(tolua_S,"Dexterity2",MagicSuffixType::Dexterity2);
   tolua_constant(tolua_S,"Skill",MagicSuffixType::Skill);
   tolua_constant(tolua_S,"Skill2",MagicSuffixType::Skill2);
   tolua_constant(tolua_S,"Accuracy",MagicSuffixType::Accuracy);
   tolua_constant(tolua_S,"Precision",MagicSuffixType::Precision);
   tolua_constant(tolua_S,"Precision2",MagicSuffixType::Precision2);
   tolua_constant(tolua_S,"Perfection",MagicSuffixType::Perfection);
   tolua_constant(tolua_S,"Balance",MagicSuffixType::Balance);
   tolua_constant(tolua_S,"Stability",MagicSuffixType::Stability);
   tolua_constant(tolua_S,"Unused63",MagicSuffixType::Unused63);
   tolua_constant(tolua_S,"Regeneration",MagicSuffixType::Regeneration);
   tolua_constant(tolua_S,"Regeneration2",MagicSuffixType::Regeneration2);
   tolua_constant(tolua_S,"Regeneration3",MagicSuffixType::Regeneration3);
   tolua_constant(tolua_S,"Regrowth",MagicSuffixType::Regrowth);
   tolua_constant(tolua_S,"Regrowth2",MagicSuffixType::Regrowth2);
   tolua_constant(tolua_S,"Vileness",MagicSuffixType::Vileness);
   tolua_constant(tolua_S,"Unused70",MagicSuffixType::Unused70);
   tolua_constant(tolua_S,"Greed",MagicSuffixType::Greed);
   tolua_constant(tolua_S,"Wealth",MagicSuffixType::Wealth);
   tolua_constant(tolua_S,"Chance",MagicSuffixType::Chance);
   tolua_constant(tolua_S,"Fortune",MagicSuffixType::Fortune);
   tolua_constant(tolua_S,"Energy",MagicSuffixType::Energy);
   tolua_constant(tolua_S,"Energy2",MagicSuffixType::Energy2);
   tolua_constant(tolua_S,"TheMind",MagicSuffixType::TheMind);
   tolua_constant(tolua_S,"Brilliance",MagicSuffixType::Brilliance);
   tolua_constant(tolua_S,"Sorcery",MagicSuffixType::Sorcery);
   tolua_constant(tolua_S,"Wizardry",MagicSuffixType::Wizardry);
   tolua_constant(tolua_S,"TheBear",MagicSuffixType::TheBear);
   tolua_constant(tolua_S,"Light",MagicSuffixType::Light);
   tolua_constant(tolua_S,"Radiance",MagicSuffixType::Radiance);
   tolua_constant(tolua_S,"TheSun",MagicSuffixType::TheSun);
   tolua_constant(tolua_S,"Life2",MagicSuffixType::Life2);
   tolua_constant(tolua_S,"TheJackal",MagicSuffixType::TheJackal);
   tolua_constant(tolua_S,"TheFox",MagicSuffixType::TheFox);
   tolua_constant(tolua_S,"TheWolf",MagicSuffixType::TheWolf);
   tolua_constant(tolua_S,"TheWolf2",MagicSuffixType::TheWolf2);
   tolua_constant(tolua_S,"TheTiger",MagicSuffixType::TheTiger);
   tolua_constant(tolua_S,"TheMammoth",MagicSuffixType::TheMammoth);
   tolua_constant(tolua_S,"TheMammoth2",MagicSuffixType::TheMammoth2);
   tolua_constant(tolua_S,"TheColosuss",MagicSuffixType::TheColosuss);
   tolua_constant(tolua_S,"TheLeech",MagicSuffixType::TheLeech);
   tolua_constant(tolua_S,"TheLocust",MagicSuffixType::TheLocust);
   tolua_constant(tolua_S,"TheBat",MagicSuffixType::TheBat);
   tolua_constant(tolua_S,"TheVampire",MagicSuffixType::TheVampire);
   tolua_constant(tolua_S,"Defiance",MagicSuffixType::Defiance);
   tolua_constant(tolua_S,"Amelioration",MagicSuffixType::Amelioration);
   tolua_constant(tolua_S,"Remedy",MagicSuffixType::Remedy);
   tolua_constant(tolua_S,"Unused101",MagicSuffixType::Unused101);
   tolua_constant(tolua_S,"Simplicity",MagicSuffixType::Simplicity);
   tolua_constant(tolua_S,"Ease",MagicSuffixType::Ease);
   tolua_constant(tolua_S,"Unused104",MagicSuffixType::Unused104);
   tolua_constant(tolua_S,"Strength",MagicSuffixType::Strength);
   tolua_constant(tolua_S,"Might",MagicSuffixType::Might);
   tolua_constant(tolua_S,"TheOx",MagicSuffixType::TheOx);
   tolua_constant(tolua_S,"TheOx2",MagicSuffixType::TheOx2);
   tolua_constant(tolua_S,"TheGiant",MagicSuffixType::TheGiant);
   tolua_constant(tolua_S,"TheGiant2",MagicSuffixType::TheGiant2);
   tolua_constant(tolua_S,"TheTitan4",MagicSuffixType::TheTitan4);
   tolua_constant(tolua_S,"Pacing",MagicSuffixType::Pacing);
   tolua_constant(tolua_S,"Haste",MagicSuffixType::Haste);
   tolua_constant(tolua_S,"Speed",MagicSuffixType::Speed);
   tolua_constant(tolua_S,"Health2",MagicSuffixType::Health2);
   tolua_constant(tolua_S,"Protection2",MagicSuffixType::Protection2);
   tolua_constant(tolua_S,"Absorption2",MagicSuffixType::Absorption2);
   tolua_constant(tolua_S,"Life3",MagicSuffixType::Life3);
   tolua_constant(tolua_S,"LifeEverlasting",MagicSuffixType::LifeEverlasting);
   tolua_constant(tolua_S,"Protection3",MagicSuffixType::Protection3);
   tolua_constant(tolua_S,"Absorption3",MagicSuffixType::Absorption3);
   tolua_constant(tolua_S,"Life4",MagicSuffixType::Life4);
   tolua_constant(tolua_S,"Anima",MagicSuffixType::Anima);
   tolua_constant(tolua_S,"Warding2",MagicSuffixType::Warding2);
   tolua_constant(tolua_S,"TheSentinel2",MagicSuffixType::TheSentinel2);
   tolua_constant(tolua_S,"Guarding2",MagicSuffixType::Guarding2);
   tolua_constant(tolua_S,"Negation2",MagicSuffixType::Negation2);
   tolua_constant(tolua_S,"TheSentinel3",MagicSuffixType::TheSentinel3);
   tolua_constant(tolua_S,"Guarding3",MagicSuffixType::Guarding3);
   tolua_constant(tolua_S,"Negation3",MagicSuffixType::Negation3);
   tolua_constant(tolua_S,"Unused131",MagicSuffixType::Unused131);
   tolua_constant(tolua_S,"Unused132",MagicSuffixType::Unused132);
   tolua_constant(tolua_S,"Unused133",MagicSuffixType::Unused133);
   tolua_constant(tolua_S,"Unused134",MagicSuffixType::Unused134);
   tolua_constant(tolua_S,"Unused135",MagicSuffixType::Unused135);
   tolua_constant(tolua_S,"Unused136",MagicSuffixType::Unused136);
   tolua_constant(tolua_S,"Unused137",MagicSuffixType::Unused137);
   tolua_constant(tolua_S,"Unused138",MagicSuffixType::Unused138);
   tolua_constant(tolua_S,"Unused139",MagicSuffixType::Unused139);
   tolua_constant(tolua_S,"Unused140",MagicSuffixType::Unused140);
   tolua_constant(tolua_S,"Unused141",MagicSuffixType::Unused141);
   tolua_constant(tolua_S,"Unused142",MagicSuffixType::Unused142);
   tolua_constant(tolua_S,"Unused143",MagicSuffixType::Unused143);
   tolua_constant(tolua_S,"Unused144",MagicSuffixType::Unused144);
   tolua_constant(tolua_S,"Unused145",MagicSuffixType::Unused145);
   tolua_constant(tolua_S,"Unused146",MagicSuffixType::Unused146);
   tolua_constant(tolua_S,"Unused147",MagicSuffixType::Unused147);
   tolua_constant(tolua_S,"Unused148",MagicSuffixType::Unused148);
   tolua_constant(tolua_S,"Unused149",MagicSuffixType::Unused149);
   tolua_constant(tolua_S,"Unused150",MagicSuffixType::Unused150);
   tolua_constant(tolua_S,"Unused151",MagicSuffixType::Unused151);
   tolua_constant(tolua_S,"Unused152",MagicSuffixType::Unused152);
   tolua_constant(tolua_S,"Unused153",MagicSuffixType::Unused153);
   tolua_constant(tolua_S,"Unused154",MagicSuffixType::Unused154);
   tolua_constant(tolua_S,"Unused155",MagicSuffixType::Unused155);
   tolua_constant(tolua_S,"Unused156",MagicSuffixType::Unused156);
   tolua_constant(tolua_S,"Unused157",MagicSuffixType::Unused157);
   tolua_constant(tolua_S,"Piercing2",MagicSuffixType::Piercing2);
   tolua_constant(tolua_S,"Unused158",MagicSuffixType::Unused158);
   tolua_constant(tolua_S,"Unused159",MagicSuffixType::Unused159);
   tolua_constant(tolua_S,"Thorns2",MagicSuffixType::Thorns2);
   tolua_constant(tolua_S,"Spikes2",MagicSuffixType::Spikes2);
   tolua_constant(tolua_S,"Razors",MagicSuffixType::Razors);
   tolua_constant(tolua_S,"Swords",MagicSuffixType::Swords);
   tolua_constant(tolua_S,"Malice",MagicSuffixType::Malice);
   tolua_constant(tolua_S,"Readiness2",MagicSuffixType::Readiness2);
   tolua_constant(tolua_S,"Alacrity2",MagicSuffixType::Alacrity2);
   tolua_constant(tolua_S,"Swiftness2",MagicSuffixType::Swiftness2);
   tolua_constant(tolua_S,"Quickness2",MagicSuffixType::Quickness2);
   tolua_constant(tolua_S,"Alacrity3",MagicSuffixType::Alacrity3);
   tolua_constant(tolua_S,"Fervor",MagicSuffixType::Fervor);
   tolua_constant(tolua_S,"Blocking2",MagicSuffixType::Blocking2);
   tolua_constant(tolua_S,"Deflecting2",MagicSuffixType::Deflecting2);
   tolua_constant(tolua_S,"TheApprentice2",MagicSuffixType::TheApprentice2);
   tolua_constant(tolua_S,"TheMagus2",MagicSuffixType::TheMagus2);
   tolua_constant(tolua_S,"Frost3",MagicSuffixType::Frost3);
   tolua_constant(tolua_S,"TheIcicle",MagicSuffixType::TheIcicle);
   tolua_constant(tolua_S,"TheGlacier2",MagicSuffixType::TheGlacier2);
   tolua_constant(tolua_S,"Winter",MagicSuffixType::Winter);
   tolua_constant(tolua_S,"Frost4",MagicSuffixType::Frost4);
   tolua_constant(tolua_S,"Frigidity",MagicSuffixType::Frigidity);
   tolua_constant(tolua_S,"Warmth2",MagicSuffixType::Warmth2);
   tolua_constant(tolua_S,"Flame3",MagicSuffixType::Flame3);
   tolua_constant(tolua_S,"Fire2",MagicSuffixType::Fire2);
   tolua_constant(tolua_S,"Burning2",MagicSuffixType::Burning2);
   tolua_constant(tolua_S,"Incineration",MagicSuffixType::Incineration);
   tolua_constant(tolua_S,"Flame4",MagicSuffixType::Flame4);
   tolua_constant(tolua_S,"Passion",MagicSuffixType::Passion);
   tolua_constant(tolua_S,"Shock3",MagicSuffixType::Shock3);
   tolua_constant(tolua_S,"Lightning2",MagicSuffixType::Lightning2);
   tolua_constant(tolua_S,"Thunder2",MagicSuffixType::Thunder2);
   tolua_constant(tolua_S,"Storms",MagicSuffixType::Storms);
   tolua_constant(tolua_S,"Shock4",MagicSuffixType::Shock4);
   tolua_constant(tolua_S,"Ennui",MagicSuffixType::Ennui);
   tolua_constant(tolua_S,"Craftsmanship2",MagicSuffixType::Craftsmanship2);
   tolua_constant(tolua_S,"Quality2",MagicSuffixType::Quality2);
   tolua_constant(tolua_S,"Maiming3",MagicSuffixType::Maiming3);
   tolua_constant(tolua_S,"Slaying2",MagicSuffixType::Slaying2);
   tolua_constant(tolua_S,"Gore2",MagicSuffixType::Gore2);
   tolua_constant(tolua_S,"Carnage2",MagicSuffixType::Carnage2);
   tolua_constant(tolua_S,"Slaughter2",MagicSuffixType::Slaughter2);
   tolua_constant(tolua_S,"Butchery",MagicSuffixType::Butchery);
   tolua_constant(tolua_S,"Evisceration",MagicSuffixType::Evisceration);
   tolua_constant(tolua_S,"Maiming4",MagicSuffixType::Maiming4);
   tolua_constant(tolua_S,"Craftsmanship3",MagicSuffixType::Craftsmanship3);
   tolua_constant(tolua_S,"Craftsmanship4",MagicSuffixType::Craftsmanship4);
   tolua_constant(tolua_S,"Craftsmanship5",MagicSuffixType::Craftsmanship5);
   tolua_constant(tolua_S,"Quality3",MagicSuffixType::Quality3);
   tolua_constant(tolua_S,"Quality4",MagicSuffixType::Quality4);
   tolua_constant(tolua_S,"Maiming5",MagicSuffixType::Maiming5);
   tolua_constant(tolua_S,"Maiming6",MagicSuffixType::Maiming6);
   tolua_constant(tolua_S,"Unused212",MagicSuffixType::Unused212);
   tolua_constant(tolua_S,"Unused213",MagicSuffixType::Unused213);
   tolua_constant(tolua_S,"Unused214",MagicSuffixType::Unused214);
   tolua_constant(tolua_S,"Unused215",MagicSuffixType::Unused215);
   tolua_constant(tolua_S,"Unused216",MagicSuffixType::Unused216);
   tolua_constant(tolua_S,"Unused217",MagicSuffixType::Unused217);
   tolua_constant(tolua_S,"Unused218",MagicSuffixType::Unused218);
   tolua_constant(tolua_S,"Unused219",MagicSuffixType::Unused219);
   tolua_constant(tolua_S,"Ire",MagicSuffixType::Ire);
   tolua_constant(tolua_S,"Wrath",MagicSuffixType::Wrath);
   tolua_constant(tolua_S,"Carnage3",MagicSuffixType::Carnage3);
   tolua_constant(tolua_S,"Worth2",MagicSuffixType::Worth2);
   tolua_constant(tolua_S,"Measure3",MagicSuffixType::Measure3);
   tolua_constant(tolua_S,"Excellence2",MagicSuffixType::Excellence2);
   tolua_constant(tolua_S,"Performance2",MagicSuffixType::Performance2);
   tolua_constant(tolua_S,"Transcendence",MagicSuffixType::Transcendence);
   tolua_constant(tolua_S,"Worth3",MagicSuffixType::Worth3);
   tolua_constant(tolua_S,"Measure4",MagicSuffixType::Measure4);
   tolua_constant(tolua_S,"Excellence3",MagicSuffixType::Excellence3);
   tolua_constant(tolua_S,"Performance3",MagicSuffixType::Performance3);
   tolua_constant(tolua_S,"Joyfulness",MagicSuffixType::Joyfulness);
   tolua_constant(tolua_S,"Bliss",MagicSuffixType::Bliss);
   tolua_constant(tolua_S,"Blight3",MagicSuffixType::Blight3);
   tolua_constant(tolua_S,"Venom2",MagicSuffixType::Venom2);
   tolua_constant(tolua_S,"Pestilence2",MagicSuffixType::Pestilence2);
   tolua_constant(tolua_S,"Anthrax",MagicSuffixType::Anthrax);
   tolua_constant(tolua_S,"Blight4",MagicSuffixType::Blight4);
   tolua_constant(tolua_S,"Envy",MagicSuffixType::Envy);
   tolua_constant(tolua_S,"Dexterity3",MagicSuffixType::Dexterity3);
   tolua_constant(tolua_S,"Skill3",MagicSuffixType::Skill3);
   tolua_constant(tolua_S,"Accuracy2",MagicSuffixType::Accuracy2);
   tolua_constant(tolua_S,"Precision3",MagicSuffixType::Precision3);
   tolua_constant(tolua_S,"Perfection2",MagicSuffixType::Perfection2);
   tolua_constant(tolua_S,"Nirvana",MagicSuffixType::Nirvana);
   tolua_constant(tolua_S,"Dexterity4",MagicSuffixType::Dexterity4);
   tolua_constant(tolua_S,"Skill4",MagicSuffixType::Skill4);
   tolua_constant(tolua_S,"Accuracy3",MagicSuffixType::Accuracy3);
   tolua_constant(tolua_S,"Precision4",MagicSuffixType::Precision4);
   tolua_constant(tolua_S,"Perfection3",MagicSuffixType::Perfection3);
   tolua_constant(tolua_S,"Dexterity5",MagicSuffixType::Dexterity5);
   tolua_constant(tolua_S,"Skill5",MagicSuffixType::Skill5);
   tolua_constant(tolua_S,"Accuracy4",MagicSuffixType::Accuracy4);
   tolua_constant(tolua_S,"Precision5",MagicSuffixType::Precision5);
   tolua_constant(tolua_S,"Dexterity6",MagicSuffixType::Dexterity6);
   tolua_constant(tolua_S,"Dexterity7",MagicSuffixType::Dexterity7);
   tolua_constant(tolua_S,"Dexterity8",MagicSuffixType::Dexterity8);
   tolua_constant(tolua_S,"Dexterity9",MagicSuffixType::Dexterity9);
   tolua_constant(tolua_S,"Dexterity10",MagicSuffixType::Dexterity10);
   tolua_constant(tolua_S,"Dexterity11",MagicSuffixType::Dexterity11);
   tolua_constant(tolua_S,"Daring",MagicSuffixType::Daring);
   tolua_constant(tolua_S,"Balance2",MagicSuffixType::Balance2);
   tolua_constant(tolua_S,"Equilibrium",MagicSuffixType::Equilibrium);
   tolua_constant(tolua_S,"Stability2",MagicSuffixType::Stability2);
   tolua_constant(tolua_S,"Balance3",MagicSuffixType::Balance3);
   tolua_constant(tolua_S,"Balance4",MagicSuffixType::Balance4);
   tolua_constant(tolua_S,"Balance5",MagicSuffixType::Balance5);
   tolua_constant(tolua_S,"Truth",MagicSuffixType::Truth);
   tolua_constant(tolua_S,"Regeneration4",MagicSuffixType::Regeneration4);
   tolua_constant(tolua_S,"Regeneration5",MagicSuffixType::Regeneration5);
   tolua_constant(tolua_S,"Regeneration6",MagicSuffixType::Regeneration6);
   tolua_constant(tolua_S,"Regrowth3",MagicSuffixType::Regrowth3);
   tolua_constant(tolua_S,"Regrowth4",MagicSuffixType::Regrowth4);
   tolua_constant(tolua_S,"Revivification",MagicSuffixType::Revivification);
   tolua_constant(tolua_S,"Honor",MagicSuffixType::Honor);
   tolua_constant(tolua_S,"Vileness2",MagicSuffixType::Vileness2);
   tolua_constant(tolua_S,"Greed2",MagicSuffixType::Greed2);
   tolua_constant(tolua_S,"Wealth2",MagicSuffixType::Wealth2);
   tolua_constant(tolua_S,"Greed3",MagicSuffixType::Greed3);
   tolua_constant(tolua_S,"Greed4",MagicSuffixType::Greed4);
   tolua_constant(tolua_S,"Greed5",MagicSuffixType::Greed5);
   tolua_constant(tolua_S,"Greed6",MagicSuffixType::Greed6);
   tolua_constant(tolua_S,"Greed7",MagicSuffixType::Greed7);
   tolua_constant(tolua_S,"Greed8",MagicSuffixType::Greed8);
   tolua_constant(tolua_S,"Avarice",MagicSuffixType::Avarice);
   tolua_constant(tolua_S,"Chance2",MagicSuffixType::Chance2);
   tolua_constant(tolua_S,"Fortune3",MagicSuffixType::Fortune3);
   tolua_constant(tolua_S,"Fortune4",MagicSuffixType::Fortune4);
   tolua_constant(tolua_S,"Luck",MagicSuffixType::Luck);
   tolua_constant(tolua_S,"Fortune5",MagicSuffixType::Fortune5);
   tolua_constant(tolua_S,"GoodLuck",MagicSuffixType::GoodLuck);
   tolua_constant(tolua_S,"Prosperity",MagicSuffixType::Prosperity);
   tolua_constant(tolua_S,"Energy3",MagicSuffixType::Energy3);
   tolua_constant(tolua_S,"TheMind2",MagicSuffixType::TheMind2);
   tolua_constant(tolua_S,"Brilliance2",MagicSuffixType::Brilliance2);
   tolua_constant(tolua_S,"Sorcery2",MagicSuffixType::Sorcery2);
   tolua_constant(tolua_S,"Wizardry2",MagicSuffixType::Wizardry2);
   tolua_constant(tolua_S,"Enlightenment",MagicSuffixType::Enlightenment);
   tolua_constant(tolua_S,"Energy4",MagicSuffixType::Energy4);
   tolua_constant(tolua_S,"TheMind3",MagicSuffixType::TheMind3);
   tolua_constant(tolua_S,"Brilliance3",MagicSuffixType::Brilliance3);
   tolua_constant(tolua_S,"Sorcery3",MagicSuffixType::Sorcery3);
   tolua_constant(tolua_S,"Wizardry3",MagicSuffixType::Wizardry3);
   tolua_constant(tolua_S,"Energy5",MagicSuffixType::Energy5);
   tolua_constant(tolua_S,"TheMind4",MagicSuffixType::TheMind4);
   tolua_constant(tolua_S,"Brilliance4",MagicSuffixType::Brilliance4);
   tolua_constant(tolua_S,"Sorcery4",MagicSuffixType::Sorcery4);
   tolua_constant(tolua_S,"Knowledge",MagicSuffixType::Knowledge);
   tolua_constant(tolua_S,"TheBear2",MagicSuffixType::TheBear2);
   tolua_constant(tolua_S,"Light2",MagicSuffixType::Light2);
   tolua_constant(tolua_S,"Radiance2",MagicSuffixType::Radiance2);
   tolua_constant(tolua_S,"TheSun2",MagicSuffixType::TheSun2);
   tolua_constant(tolua_S,"TheJackal2",MagicSuffixType::TheJackal2);
   tolua_constant(tolua_S,"TheFox2",MagicSuffixType::TheFox2);
   tolua_constant(tolua_S,"TheWolf3",MagicSuffixType::TheWolf3);
   tolua_constant(tolua_S,"TheTiger2",MagicSuffixType::TheTiger2);
   tolua_constant(tolua_S,"TheMammoth3",MagicSuffixType::TheMammoth3);
   tolua_constant(tolua_S,"TheColosuss2",MagicSuffixType::TheColosuss2);
   tolua_constant(tolua_S,"TheSquid",MagicSuffixType::TheSquid);
   tolua_constant(tolua_S,"TheWhale",MagicSuffixType::TheWhale);
   tolua_constant(tolua_S,"TheJackal3",MagicSuffixType::TheJackal3);
   tolua_constant(tolua_S,"TheFox3",MagicSuffixType::TheFox3);
   tolua_constant(tolua_S,"TheWolf4",MagicSuffixType::TheWolf4);
   tolua_constant(tolua_S,"TheTiger3",MagicSuffixType::TheTiger3);
   tolua_constant(tolua_S,"TheMammoth4",MagicSuffixType::TheMammoth4);
   tolua_constant(tolua_S,"TheColosuss3",MagicSuffixType::TheColosuss3);
   tolua_constant(tolua_S,"TheJackal4",MagicSuffixType::TheJackal4);
   tolua_constant(tolua_S,"TheFox4",MagicSuffixType::TheFox4);
   tolua_constant(tolua_S,"TheWolf5",MagicSuffixType::TheWolf5);
   tolua_constant(tolua_S,"TheTiger4",MagicSuffixType::TheTiger4);
   tolua_constant(tolua_S,"TheMammoth5",MagicSuffixType::TheMammoth5);
   tolua_constant(tolua_S,"Life5",MagicSuffixType::Life5);
   tolua_constant(tolua_S,"Life6",MagicSuffixType::Life6);
   tolua_constant(tolua_S,"Life7",MagicSuffixType::Life7);
   tolua_constant(tolua_S,"Substinence",MagicSuffixType::Substinence);
   tolua_constant(tolua_S,"Substinence2",MagicSuffixType::Substinence2);
   tolua_constant(tolua_S,"Substinence3",MagicSuffixType::Substinence3);
   tolua_constant(tolua_S,"Vita",MagicSuffixType::Vita);
   tolua_constant(tolua_S,"Vita2",MagicSuffixType::Vita2);
   tolua_constant(tolua_S,"Vita3",MagicSuffixType::Vita3);
   tolua_constant(tolua_S,"Life8",MagicSuffixType::Life8);
   tolua_constant(tolua_S,"Life9",MagicSuffixType::Life9);
   tolua_constant(tolua_S,"Substinence4",MagicSuffixType::Substinence4);
   tolua_constant(tolua_S,"Substinence5",MagicSuffixType::Substinence5);
   tolua_constant(tolua_S,"Vita4",MagicSuffixType::Vita4);
   tolua_constant(tolua_S,"Vita5",MagicSuffixType::Vita5);
   tolua_constant(tolua_S,"Life10",MagicSuffixType::Life10);
   tolua_constant(tolua_S,"Substinence6",MagicSuffixType::Substinence6);
   tolua_constant(tolua_S,"Vita6",MagicSuffixType::Vita6);
   tolua_constant(tolua_S,"Spirit",MagicSuffixType::Spirit);
   tolua_constant(tolua_S,"Hope",MagicSuffixType::Hope);
   tolua_constant(tolua_S,"TheLeech2",MagicSuffixType::TheLeech2);
   tolua_constant(tolua_S,"TheLocust2",MagicSuffixType::TheLocust2);
   tolua_constant(tolua_S,"TheLamprey",MagicSuffixType::TheLamprey);
   tolua_constant(tolua_S,"TheLeech3",MagicSuffixType::TheLeech3);
   tolua_constant(tolua_S,"TheLocust3",MagicSuffixType::TheLocust3);
   tolua_constant(tolua_S,"TheLamprey2",MagicSuffixType::TheLamprey2);
   tolua_constant(tolua_S,"TheLeech4",MagicSuffixType::TheLeech4);
   tolua_constant(tolua_S,"TheBat2",MagicSuffixType::TheBat2);
   tolua_constant(tolua_S,"TheWraith",MagicSuffixType::TheWraith);
   tolua_constant(tolua_S,"TheVampire2",MagicSuffixType::TheVampire2);
   tolua_constant(tolua_S,"TheBat3",MagicSuffixType::TheBat3);
   tolua_constant(tolua_S,"TheWraith2",MagicSuffixType::TheWraith2);
   tolua_constant(tolua_S,"TheVampire3",MagicSuffixType::TheVampire3);
   tolua_constant(tolua_S,"TheBat4",MagicSuffixType::TheBat4);
   tolua_constant(tolua_S,"Defiance2",MagicSuffixType::Defiance2);
   tolua_constant(tolua_S,"Amelioration2",MagicSuffixType::Amelioration2);
   tolua_constant(tolua_S,"Remedy2",MagicSuffixType::Remedy2);
   tolua_constant(tolua_S,"Simplicity2",MagicSuffixType::Simplicity2);
   tolua_constant(tolua_S,"Ease2",MagicSuffixType::Ease2);
   tolua_constant(tolua_S,"Freedom",MagicSuffixType::Freedom);
   tolua_constant(tolua_S,"Strength2",MagicSuffixType::Strength2);
   tolua_constant(tolua_S,"Might2",MagicSuffixType::Might2);
   tolua_constant(tolua_S,"TheOx3",MagicSuffixType::TheOx3);
   tolua_constant(tolua_S,"TheGiant3",MagicSuffixType::TheGiant3);
   tolua_constant(tolua_S,"TheTitan2",MagicSuffixType::TheTitan2);
   tolua_constant(tolua_S,"Atlus",MagicSuffixType::Atlus);
   tolua_constant(tolua_S,"Strength3",MagicSuffixType::Strength3);
   tolua_constant(tolua_S,"Might3",MagicSuffixType::Might3);
   tolua_constant(tolua_S,"TheOx4",MagicSuffixType::TheOx4);
   tolua_constant(tolua_S,"TheGiant4",MagicSuffixType::TheGiant4);
   tolua_constant(tolua_S,"TheTitan3",MagicSuffixType::TheTitan3);
   tolua_constant(tolua_S,"Strength4",MagicSuffixType::Strength4);
   tolua_constant(tolua_S,"Might4",MagicSuffixType::Might4);
   tolua_constant(tolua_S,"TheOx5",MagicSuffixType::TheOx5);
   tolua_constant(tolua_S,"TheGiant5",MagicSuffixType::TheGiant5);
   tolua_constant(tolua_S,"Strength5",MagicSuffixType::Strength5);
   tolua_constant(tolua_S,"Strength6",MagicSuffixType::Strength6);
   tolua_constant(tolua_S,"Strength7",MagicSuffixType::Strength7);
   tolua_constant(tolua_S,"Strength8",MagicSuffixType::Strength8);
   tolua_constant(tolua_S,"Strength9",MagicSuffixType::Strength9);
   tolua_constant(tolua_S,"Strength10",MagicSuffixType::Strength10);
   tolua_constant(tolua_S,"Virility",MagicSuffixType::Virility);
   tolua_constant(tolua_S,"Pacing2",MagicSuffixType::Pacing2);
   tolua_constant(tolua_S,"Haste2",MagicSuffixType::Haste2);
   tolua_constant(tolua_S,"Speed2",MagicSuffixType::Speed2);
   tolua_constant(tolua_S,"Traveling",MagicSuffixType::Traveling);
   tolua_constant(tolua_S,"Acceleration",MagicSuffixType::Acceleration);
   tolua_constant(tolua_S,"Inertia",MagicSuffixType::Inertia);
   tolua_constant(tolua_S,"Inertia2",MagicSuffixType::Inertia2);
   tolua_constant(tolua_S,"Inertia3",MagicSuffixType::Inertia3);
   tolua_constant(tolua_S,"Self",MagicSuffixType::Self);
   tolua_constant(tolua_S,"FastRepair",MagicSuffixType::FastRepair);
   tolua_constant(tolua_S,"Ages",MagicSuffixType::Ages);
   tolua_constant(tolua_S,"Replenishing",MagicSuffixType::Replenishing);
   tolua_constant(tolua_S,"Propogation",MagicSuffixType::Propogation);
   tolua_constant(tolua_S,"TheKraken",MagicSuffixType::TheKraken);
   tolua_constant(tolua_S,"Memory",MagicSuffixType::Memory);
   tolua_constant(tolua_S,"TheElephant",MagicSuffixType::TheElephant);
   tolua_constant(tolua_S,"Unused410",MagicSuffixType::Unused410);
   tolua_constant(tolua_S,"Unused411",MagicSuffixType::Unused411);
   tolua_constant(tolua_S,"Unused412",MagicSuffixType::Unused412);
   tolua_constant(tolua_S,"Unused413",MagicSuffixType::Unused413);
   tolua_constant(tolua_S,"Unused414",MagicSuffixType::Unused414);
   tolua_constant(tolua_S,"Unused415",MagicSuffixType::Unused415);
   tolua_constant(tolua_S,"Unused416",MagicSuffixType::Unused416);
   tolua_constant(tolua_S,"Unused417",MagicSuffixType::Unused417);
   tolua_constant(tolua_S,"Firebolts",MagicSuffixType::Firebolts);
   tolua_constant(tolua_S,"Firebolts2",MagicSuffixType::Firebolts2);
   tolua_constant(tolua_S,"Firebolts3",MagicSuffixType::Firebolts3);
   tolua_constant(tolua_S,"ChargedShield",MagicSuffixType::ChargedShield);
   tolua_constant(tolua_S,"ChargedShield2",MagicSuffixType::ChargedShield2);
   tolua_constant(tolua_S,"ChargedShield3",MagicSuffixType::ChargedShield3);
   tolua_constant(tolua_S,"Icebolt",MagicSuffixType::Icebolt);
   tolua_constant(tolua_S,"Unused425",MagicSuffixType::Unused425);
   tolua_constant(tolua_S,"Unused426",MagicSuffixType::Unused426);
   tolua_constant(tolua_S,"Unused427",MagicSuffixType::Unused427);
   tolua_constant(tolua_S,"FrostShield",MagicSuffixType::FrostShield);
   tolua_constant(tolua_S,"Unused429",MagicSuffixType::Unused429);
   tolua_constant(tolua_S,"Unused430",MagicSuffixType::Unused430);
   tolua_constant(tolua_S,"Unused431",MagicSuffixType::Unused431);
   tolua_constant(tolua_S,"Nova",MagicSuffixType::Nova);
   tolua_constant(tolua_S,"Nova2",MagicSuffixType::Nova2);
   tolua_constant(tolua_S,"NovaShield",MagicSuffixType::NovaShield);
   tolua_constant(tolua_S,"NovaShield2",MagicSuffixType::NovaShield2);
   tolua_constant(tolua_S,"NovaShield3",MagicSuffixType::NovaShield3);
   tolua_constant(tolua_S,"Lightning3",MagicSuffixType::Lightning3);
   tolua_constant(tolua_S,"Unused438",MagicSuffixType::Unused438);
   tolua_constant(tolua_S,"Unused439",MagicSuffixType::Unused439);
   tolua_constant(tolua_S,"Unused440",MagicSuffixType::Unused440);
   tolua_constant(tolua_S,"Unused441",MagicSuffixType::Unused441);
   tolua_constant(tolua_S,"ChainLightning",MagicSuffixType::ChainLightning);
   tolua_constant(tolua_S,"ChainLightning2",MagicSuffixType::ChainLightning2);
   tolua_constant(tolua_S,"ChainLightning3",MagicSuffixType::ChainLightning3);
   tolua_constant(tolua_S,"Unused445",MagicSuffixType::Unused445);
   tolua_constant(tolua_S,"Unused446",MagicSuffixType::Unused446);
   tolua_constant(tolua_S,"Unused447",MagicSuffixType::Unused447);
   tolua_constant(tolua_S,"Unused448",MagicSuffixType::Unused448);
   tolua_constant(tolua_S,"Unused449",MagicSuffixType::Unused449);
   tolua_constant(tolua_S,"Unused450",MagicSuffixType::Unused450);
   tolua_constant(tolua_S,"Unused451",MagicSuffixType::Unused451);
   tolua_constant(tolua_S,"Unused452",MagicSuffixType::Unused452);
   tolua_constant(tolua_S,"Unused453",MagicSuffixType::Unused453);
   tolua_constant(tolua_S,"HydraShield",MagicSuffixType::HydraShield);
   tolua_constant(tolua_S,"Unused455",MagicSuffixType::Unused455);
   tolua_constant(tolua_S,"Unused456",MagicSuffixType::Unused456);
   tolua_constant(tolua_S,"Unused457",MagicSuffixType::Unused457);
   tolua_constant(tolua_S,"MagicArrows",MagicSuffixType::MagicArrows);
   tolua_constant(tolua_S,"Unused459",MagicSuffixType::Unused459);
   tolua_constant(tolua_S,"Unused460",MagicSuffixType::Unused460);
   tolua_constant(tolua_S,"FireArrows",MagicSuffixType::FireArrows);
   tolua_constant(tolua_S,"InnerSight",MagicSuffixType::InnerSight);
   tolua_constant(tolua_S,"InnerSight2",MagicSuffixType::InnerSight2);
   tolua_constant(tolua_S,"Unused464",MagicSuffixType::Unused464);
   tolua_constant(tolua_S,"Unused465",MagicSuffixType::Unused465);
   tolua_constant(tolua_S,"ColdArrows",MagicSuffixType::ColdArrows);
   tolua_constant(tolua_S,"ColdArrows2",MagicSuffixType::ColdArrows2);
   tolua_constant(tolua_S,"MultipleShot",MagicSuffixType::MultipleShot);
   tolua_constant(tolua_S,"MultipleShot2",MagicSuffixType::MultipleShot2);
   tolua_constant(tolua_S,"PowerStrike",MagicSuffixType::PowerStrike);
   tolua_constant(tolua_S,"PowerStrike2",MagicSuffixType::PowerStrike2);
   tolua_constant(tolua_S,"Unused472",MagicSuffixType::Unused472);
   tolua_constant(tolua_S,"Unused473",MagicSuffixType::Unused473);
   tolua_constant(tolua_S,"ExplodingArrows",MagicSuffixType::ExplodingArrows);
   tolua_constant(tolua_S,"ExplodingArrows2",MagicSuffixType::ExplodingArrows2);
   tolua_constant(tolua_S,"Unused476",MagicSuffixType::Unused476);
   tolua_constant(tolua_S,"Unused477",MagicSuffixType::Unused477);
   tolua_constant(tolua_S,"Unused478",MagicSuffixType::Unused478);
   tolua_constant(tolua_S,"Unused479",MagicSuffixType::Unused479);
   tolua_constant(tolua_S,"Unused480",MagicSuffixType::Unused480);
   tolua_constant(tolua_S,"Unused481",MagicSuffixType::Unused481);
   tolua_constant(tolua_S,"IceArrows",MagicSuffixType::IceArrows);
   tolua_constant(tolua_S,"IceArrows2",MagicSuffixType::IceArrows2);
   tolua_constant(tolua_S,"Unused484",MagicSuffixType::Unused484);
   tolua_constant(tolua_S,"Unused485",MagicSuffixType::Unused485);
   tolua_constant(tolua_S,"ChargedStrike",MagicSuffixType::ChargedStrike);
   tolua_constant(tolua_S,"ChargedStrike2",MagicSuffixType::ChargedStrike2);
   tolua_constant(tolua_S,"Unused488",MagicSuffixType::Unused488);
   tolua_constant(tolua_S,"Unused489",MagicSuffixType::Unused489);
   tolua_constant(tolua_S,"Unused490",MagicSuffixType::Unused490);
   tolua_constant(tolua_S,"Unused491",MagicSuffixType::Unused491);
   tolua_constant(tolua_S,"Unused492",MagicSuffixType::Unused492);
   tolua_constant(tolua_S,"Unused493",MagicSuffixType::Unused493);
   tolua_constant(tolua_S,"FreezingArrows",MagicSuffixType::FreezingArrows);
   tolua_constant(tolua_S,"FreezingArrows2",MagicSuffixType::FreezingArrows2);
   tolua_constant(tolua_S,"LightningStrike",MagicSuffixType::LightningStrike);
   tolua_constant(tolua_S,"LightningStrike2",MagicSuffixType::LightningStrike2);
   tolua_constant(tolua_S,"Unused498",MagicSuffixType::Unused498);
   tolua_constant(tolua_S,"Unused499",MagicSuffixType::Unused499);
   tolua_constant(tolua_S,"FireBolts",MagicSuffixType::FireBolts);
   tolua_constant(tolua_S,"FireBolts2",MagicSuffixType::FireBolts2);
   tolua_constant(tolua_S,"ChargedBolts",MagicSuffixType::ChargedBolts);
   tolua_constant(tolua_S,"ChargedBolts2",MagicSuffixType::ChargedBolts2);
   tolua_constant(tolua_S,"IceBolts",MagicSuffixType::IceBolts);
   tolua_constant(tolua_S,"IceBolts2",MagicSuffixType::IceBolts2);
   tolua_constant(tolua_S,"Unused506",MagicSuffixType::Unused506);
   tolua_constant(tolua_S,"Unused507",MagicSuffixType::Unused507);
   tolua_constant(tolua_S,"Unused508",MagicSuffixType::Unused508);
   tolua_constant(tolua_S,"Unused509",MagicSuffixType::Unused509);
   tolua_constant(tolua_S,"Telekinesis",MagicSuffixType::Telekinesis);
   tolua_constant(tolua_S,"Telekinesis2",MagicSuffixType::Telekinesis2);
   tolua_constant(tolua_S,"FrostNovas",MagicSuffixType::FrostNovas);
   tolua_constant(tolua_S,"FrostNovas2",MagicSuffixType::FrostNovas2);
   tolua_constant(tolua_S,"IceBlasts",MagicSuffixType::IceBlasts);
   tolua_constant(tolua_S,"IceBlasts2",MagicSuffixType::IceBlasts2);
   tolua_constant(tolua_S,"Unused516",MagicSuffixType::Unused516);
   tolua_constant(tolua_S,"Unused517",MagicSuffixType::Unused517);
   tolua_constant(tolua_S,"FireBalls",MagicSuffixType::FireBalls);
   tolua_constant(tolua_S,"FireBalls2",MagicSuffixType::FireBalls2);
   tolua_constant(tolua_S,"Novas",MagicSuffixType::Novas);
   tolua_constant(tolua_S,"Novas2",MagicSuffixType::Novas2);
   tolua_constant(tolua_S,"Lightning4",MagicSuffixType::Lightning4);
   tolua_constant(tolua_S,"Lightning5",MagicSuffixType::Lightning5);
   tolua_constant(tolua_S,"Unused524",MagicSuffixType::Unused524);
   tolua_constant(tolua_S,"Unused525",MagicSuffixType::Unused525);
   tolua_constant(tolua_S,"Unused526",MagicSuffixType::Unused526);
   tolua_constant(tolua_S,"Unused527",MagicSuffixType::Unused527);
   tolua_constant(tolua_S,"Enchantment",MagicSuffixType::Enchantment);
   tolua_constant(tolua_S,"Enchantment2",MagicSuffixType::Enchantment2);
   tolua_constant(tolua_S,"ChainLightning4",MagicSuffixType::ChainLightning4);
   tolua_constant(tolua_S,"ChainLightning5",MagicSuffixType::ChainLightning5);
   tolua_constant(tolua_S,"Teleportation",MagicSuffixType::Teleportation);
   tolua_constant(tolua_S,"Teleportation2",MagicSuffixType::Teleportation2);
   tolua_constant(tolua_S,"GlacialSpikes",MagicSuffixType::GlacialSpikes);
   tolua_constant(tolua_S,"GlacialSpikes2",MagicSuffixType::GlacialSpikes2);
   tolua_constant(tolua_S,"Meteors",MagicSuffixType::Meteors);
   tolua_constant(tolua_S,"Meteors2",MagicSuffixType::Meteors2);
   tolua_constant(tolua_S,"Unused538",MagicSuffixType::Unused538);
   tolua_constant(tolua_S,"Unused539",MagicSuffixType::Unused539);
   tolua_constant(tolua_S,"Unused540",MagicSuffixType::Unused540);
   tolua_constant(tolua_S,"Unused541",MagicSuffixType::Unused541);
   tolua_constant(tolua_S,"Blizzards",MagicSuffixType::Blizzards);
   tolua_constant(tolua_S,"Blizzards2",MagicSuffixType::Blizzards2);
   tolua_constant(tolua_S,"Unused544",MagicSuffixType::Unused544);
   tolua_constant(tolua_S,"Unused545",MagicSuffixType::Unused545);
   tolua_constant(tolua_S,"Unused546",MagicSuffixType::Unused546);
   tolua_constant(tolua_S,"Unused547",MagicSuffixType::Unused547);
   tolua_constant(tolua_S,"FrozenOrbs",MagicSuffixType::FrozenOrbs);
   tolua_constant(tolua_S,"FrozenOrbs2",MagicSuffixType::FrozenOrbs2);
   tolua_constant(tolua_S,"Unused550",MagicSuffixType::Unused550);
   tolua_constant(tolua_S,"Unused551",MagicSuffixType::Unused551);
   tolua_constant(tolua_S,"Teeth",MagicSuffixType::Teeth);
   tolua_constant(tolua_S,"Teeth2",MagicSuffixType::Teeth2);
   tolua_constant(tolua_S,"Unused554",MagicSuffixType::Unused554);
   tolua_constant(tolua_S,"Unused555",MagicSuffixType::Unused555);
   tolua_constant(tolua_S,"Unused556",MagicSuffixType::Unused556);
   tolua_constant(tolua_S,"Unused557",MagicSuffixType::Unused557);
   tolua_constant(tolua_S,"DimVision",MagicSuffixType::DimVision);
   tolua_constant(tolua_S,"DimVision2",MagicSuffixType::DimVision2);
   tolua_constant(tolua_S,"Weaken",MagicSuffixType::Weaken);
   tolua_constant(tolua_S,"Weaken2",MagicSuffixType::Weaken2);
   tolua_constant(tolua_S,"PoisonDagger",MagicSuffixType::PoisonDagger);
   tolua_constant(tolua_S,"PoisonDagger2",MagicSuffixType::PoisonDagger2);
   tolua_constant(tolua_S,"Unused564",MagicSuffixType::Unused564);
   tolua_constant(tolua_S,"Unused565",MagicSuffixType::Unused565);
   tolua_constant(tolua_S,"Unused566",MagicSuffixType::Unused566);
   tolua_constant(tolua_S,"Unused567",MagicSuffixType::Unused567);
   tolua_constant(tolua_S,"Unused568",MagicSuffixType::Unused568);
   tolua_constant(tolua_S,"Unused569",MagicSuffixType::Unused569);
   tolua_constant(tolua_S,"Terror",MagicSuffixType::Terror);
   tolua_constant(tolua_S,"Terror2",MagicSuffixType::Terror2);
   tolua_constant(tolua_S,"Unused572",MagicSuffixType::Unused572);
   tolua_constant(tolua_S,"Unused573",MagicSuffixType::Unused573);
   tolua_constant(tolua_S,"Unused574",MagicSuffixType::Unused574);
   tolua_constant(tolua_S,"Unused575",MagicSuffixType::Unused575);
   tolua_constant(tolua_S,"Confusion",MagicSuffixType::Confusion);
   tolua_constant(tolua_S,"Confusion2",MagicSuffixType::Confusion2);
   tolua_constant(tolua_S,"LifeTap",MagicSuffixType::LifeTap);
   tolua_constant(tolua_S,"LifeTap2",MagicSuffixType::LifeTap2);
   tolua_constant(tolua_S,"Unused580",MagicSuffixType::Unused580);
   tolua_constant(tolua_S,"Unused581",MagicSuffixType::Unused581);
   tolua_constant(tolua_S,"BoneSpears",MagicSuffixType::BoneSpears);
   tolua_constant(tolua_S,"BoneSpears2",MagicSuffixType::BoneSpears2);
   tolua_constant(tolua_S,"Unused584",MagicSuffixType::Unused584);
   tolua_constant(tolua_S,"Unused585",MagicSuffixType::Unused585);
   tolua_constant(tolua_S,"Attraction",MagicSuffixType::Attraction);
   tolua_constant(tolua_S,"Attraction2",MagicSuffixType::Attraction2);
   tolua_constant(tolua_S,"Unused588",MagicSuffixType::Unused588);
   tolua_constant(tolua_S,"Unused589",MagicSuffixType::Unused589);
   tolua_constant(tolua_S,"Unused590",MagicSuffixType::Unused590);
   tolua_constant(tolua_S,"Unused591",MagicSuffixType::Unused591);
   tolua_constant(tolua_S,"Unused592",MagicSuffixType::Unused592);
   tolua_constant(tolua_S,"Unused593",MagicSuffixType::Unused593);
   tolua_constant(tolua_S,"LowerResistance",MagicSuffixType::LowerResistance);
   tolua_constant(tolua_S,"LowerResistance2",MagicSuffixType::LowerResistance2);
   tolua_constant(tolua_S,"PoisonNovas",MagicSuffixType::PoisonNovas);
   tolua_constant(tolua_S,"PoisonNovas2",MagicSuffixType::PoisonNovas2);
   tolua_constant(tolua_S,"BoneSpirits",MagicSuffixType::BoneSpirits);
   tolua_constant(tolua_S,"BoneSpirits2",MagicSuffixType::BoneSpirits2);
   tolua_constant(tolua_S,"Unused600",MagicSuffixType::Unused600);
   tolua_constant(tolua_S,"Unused601",MagicSuffixType::Unused601);
   tolua_constant(tolua_S,"Unused602",MagicSuffixType::Unused602);
   tolua_constant(tolua_S,"Unused603",MagicSuffixType::Unused603);
   tolua_constant(tolua_S,"Sacrifice",MagicSuffixType::Sacrifice);
   tolua_constant(tolua_S,"Sacrifice2",MagicSuffixType::Sacrifice2);
   tolua_constant(tolua_S,"HolyBolts",MagicSuffixType::HolyBolts);
   tolua_constant(tolua_S,"HolyBolts2",MagicSuffixType::HolyBolts2);
   tolua_constant(tolua_S,"Zeal",MagicSuffixType::Zeal);
   tolua_constant(tolua_S,"Zeal2",MagicSuffixType::Zeal2);
   tolua_constant(tolua_S,"Vengeance",MagicSuffixType::Vengeance);
   tolua_constant(tolua_S,"Vengeance2",MagicSuffixType::Vengeance2);
   tolua_constant(tolua_S,"BlessedHammers",MagicSuffixType::BlessedHammers);
   tolua_constant(tolua_S,"BlessedHammers2",MagicSuffixType::BlessedHammers2);
   tolua_constant(tolua_S,"Unused614",MagicSuffixType::Unused614);
   tolua_constant(tolua_S,"Unused615",MagicSuffixType::Unused615);
   tolua_constant(tolua_S,"Unused616",MagicSuffixType::Unused616);
   tolua_constant(tolua_S,"Unused617",MagicSuffixType::Unused617);
   tolua_constant(tolua_S,"Bashing2",MagicSuffixType::Bashing2);
   tolua_constant(tolua_S,"Bashing3",MagicSuffixType::Bashing3);
   tolua_constant(tolua_S,"Unused620",MagicSuffixType::Unused620);
   tolua_constant(tolua_S,"Unused621",MagicSuffixType::Unused621);
   tolua_constant(tolua_S,"Unused622",MagicSuffixType::Unused622);
   tolua_constant(tolua_S,"Unused623",MagicSuffixType::Unused623);
   tolua_constant(tolua_S,"Unused624",MagicSuffixType::Unused624);
   tolua_constant(tolua_S,"Unused625",MagicSuffixType::Unused625);
   tolua_constant(tolua_S,"Unused626",MagicSuffixType::Unused626);
   tolua_constant(tolua_S,"Unused627",MagicSuffixType::Unused627);
   tolua_constant(tolua_S,"Stunning",MagicSuffixType::Stunning);
   tolua_constant(tolua_S,"Stunning2",MagicSuffixType::Stunning2);
   tolua_constant(tolua_S,"Unused630",MagicSuffixType::Unused630);
   tolua_constant(tolua_S,"Unused631",MagicSuffixType::Unused631);
   tolua_constant(tolua_S,"Concentration",MagicSuffixType::Concentration);
   tolua_constant(tolua_S,"Concentration2",MagicSuffixType::Concentration2);
   tolua_constant(tolua_S,"Unused634",MagicSuffixType::Unused634);
   tolua_constant(tolua_S,"Unused635",MagicSuffixType::Unused635);
   tolua_constant(tolua_S,"Unused636",MagicSuffixType::Unused636);
   tolua_constant(tolua_S,"Unused637",MagicSuffixType::Unused637);
   tolua_constant(tolua_S,"GrimWard",MagicSuffixType::GrimWard);
   tolua_constant(tolua_S,"GrimWard2",MagicSuffixType::GrimWard2);
   tolua_constant(tolua_S,"Unused640",MagicSuffixType::Unused640);
   tolua_constant(tolua_S,"Unused641",MagicSuffixType::Unused641);
   tolua_constant(tolua_S,"Unused642",MagicSuffixType::Unused642);
   tolua_constant(tolua_S,"Unused643",MagicSuffixType::Unused643);
   tolua_constant(tolua_S,"Firestorms",MagicSuffixType::Firestorms);
   tolua_constant(tolua_S,"Firestorms2",MagicSuffixType::Firestorms2);
   tolua_constant(tolua_S,"Unused644",MagicSuffixType::Unused644);
   tolua_constant(tolua_S,"Unused645",MagicSuffixType::Unused645);
   tolua_constant(tolua_S,"Eruption",MagicSuffixType::Eruption);
   tolua_constant(tolua_S,"Eruption2",MagicSuffixType::Eruption2);
   tolua_constant(tolua_S,"Unused650",MagicSuffixType::Unused650);
   tolua_constant(tolua_S,"Unused651",MagicSuffixType::Unused651);
   tolua_constant(tolua_S,"Twister",MagicSuffixType::Twister);
   tolua_constant(tolua_S,"Twister2",MagicSuffixType::Twister2);
   tolua_constant(tolua_S,"Volcano",MagicSuffixType::Volcano);
   tolua_constant(tolua_S,"Volcano2",MagicSuffixType::Volcano2);
   tolua_constant(tolua_S,"Tornado",MagicSuffixType::Tornado);
   tolua_constant(tolua_S,"Tornado2",MagicSuffixType::Tornado2);
   tolua_constant(tolua_S,"Unused658",MagicSuffixType::Unused658);
   tolua_constant(tolua_S,"Unused659",MagicSuffixType::Unused659);
   tolua_constant(tolua_S,"Unused660",MagicSuffixType::Unused660);
   tolua_constant(tolua_S,"Unused661",MagicSuffixType::Unused661);
   tolua_constant(tolua_S,"DamageAmplification",MagicSuffixType::DamageAmplification);
   tolua_constant(tolua_S,"TheIcicle2",MagicSuffixType::TheIcicle2);
   tolua_constant(tolua_S,"TheGlacier3",MagicSuffixType::TheGlacier3);
   tolua_constant(tolua_S,"Fire3",MagicSuffixType::Fire3);
   tolua_constant(tolua_S,"Burning3",MagicSuffixType::Burning3);
   tolua_constant(tolua_S,"Lightning6",MagicSuffixType::Lightning6);
   tolua_constant(tolua_S,"Thunder3",MagicSuffixType::Thunder3);
   tolua_constant(tolua_S,"Daring2",MagicSuffixType::Daring2);
   tolua_constant(tolua_S,"Daring3",MagicSuffixType::Daring3);
   tolua_constant(tolua_S,"Knowledge2",MagicSuffixType::Knowledge2);
   tolua_constant(tolua_S,"Knowledge3",MagicSuffixType::Knowledge3);
   tolua_constant(tolua_S,"Virility2",MagicSuffixType::Virility2);
   tolua_constant(tolua_S,"Virility3",MagicSuffixType::Virility3);
   tolua_constant(tolua_S,"Readiness3",MagicSuffixType::Readiness3);
   tolua_constant(tolua_S,"Craftsmanship6",MagicSuffixType::Craftsmanship6);
   tolua_constant(tolua_S,"Quality5",MagicSuffixType::Quality5);
   tolua_constant(tolua_S,"Maiming7",MagicSuffixType::Maiming7);
   tolua_constant(tolua_S,"Craftsmanship7",MagicSuffixType::Craftsmanship7);
   tolua_constant(tolua_S,"Quality6",MagicSuffixType::Quality6);
   tolua_constant(tolua_S,"Craftsmanship8",MagicSuffixType::Craftsmanship8);
   tolua_constant(tolua_S,"Blight5",MagicSuffixType::Blight5);
   tolua_constant(tolua_S,"Venom3",MagicSuffixType::Venom3);
   tolua_constant(tolua_S,"Pestilence3",MagicSuffixType::Pestilence3);
   tolua_constant(tolua_S,"Anthrax2",MagicSuffixType::Anthrax2);
   tolua_constant(tolua_S,"Blight6",MagicSuffixType::Blight6);
   tolua_constant(tolua_S,"Venom4",MagicSuffixType::Venom4);
   tolua_constant(tolua_S,"Pestilence4",MagicSuffixType::Pestilence4);
   tolua_constant(tolua_S,"Anthrax3",MagicSuffixType::Anthrax3);
   tolua_constant(tolua_S,"Blight7",MagicSuffixType::Blight7);
   tolua_constant(tolua_S,"Venom5",MagicSuffixType::Venom5);
   tolua_constant(tolua_S,"Pestilence5",MagicSuffixType::Pestilence5);
   tolua_constant(tolua_S,"Anthrax4",MagicSuffixType::Anthrax4);
   tolua_constant(tolua_S,"Frost5",MagicSuffixType::Frost5);
   tolua_constant(tolua_S,"TheIcicle3",MagicSuffixType::TheIcicle3);
   tolua_constant(tolua_S,"TheGlacier4",MagicSuffixType::TheGlacier4);
   tolua_constant(tolua_S,"Winter2",MagicSuffixType::Winter2);
   tolua_constant(tolua_S,"Frost6",MagicSuffixType::Frost6);
   tolua_constant(tolua_S,"TheIcicle4",MagicSuffixType::TheIcicle4);
   tolua_constant(tolua_S,"TheGlacier5",MagicSuffixType::TheGlacier5);
   tolua_constant(tolua_S,"Winter3",MagicSuffixType::Winter3);
   tolua_constant(tolua_S,"Frost7",MagicSuffixType::Frost7);
   tolua_constant(tolua_S,"TheIcicle5",MagicSuffixType::TheIcicle5);
   tolua_constant(tolua_S,"TheGlacier6",MagicSuffixType::TheGlacier6);
   tolua_constant(tolua_S,"Winter4",MagicSuffixType::Winter4);
   tolua_constant(tolua_S,"Flame5",MagicSuffixType::Flame5);
   tolua_constant(tolua_S,"Fire4",MagicSuffixType::Fire4);
   tolua_constant(tolua_S,"Burning4",MagicSuffixType::Burning4);
   tolua_constant(tolua_S,"Incineration2",MagicSuffixType::Incineration2);
   tolua_constant(tolua_S,"Flame6",MagicSuffixType::Flame6);
   tolua_constant(tolua_S,"Fire5",MagicSuffixType::Fire5);
   tolua_constant(tolua_S,"Burning5",MagicSuffixType::Burning5);
   tolua_constant(tolua_S,"Incineration3",MagicSuffixType::Incineration3);
   tolua_constant(tolua_S,"Flame7",MagicSuffixType::Flame7);
   tolua_constant(tolua_S,"Fire6",MagicSuffixType::Fire6);
   tolua_constant(tolua_S,"Burning6",MagicSuffixType::Burning6);
   tolua_constant(tolua_S,"Incineration4",MagicSuffixType::Incineration4);
   tolua_constant(tolua_S,"Shock5",MagicSuffixType::Shock5);
   tolua_constant(tolua_S,"Lightning7",MagicSuffixType::Lightning7);
   tolua_constant(tolua_S,"Thunder4",MagicSuffixType::Thunder4);
   tolua_constant(tolua_S,"Storms2",MagicSuffixType::Storms2);
   tolua_constant(tolua_S,"Shock6",MagicSuffixType::Shock6);
   tolua_constant(tolua_S,"Lightning8",MagicSuffixType::Lightning8);
   tolua_constant(tolua_S,"Thunder5",MagicSuffixType::Thunder5);
   tolua_constant(tolua_S,"Storms3",MagicSuffixType::Storms3);
   tolua_constant(tolua_S,"Shock7",MagicSuffixType::Shock7);
   tolua_constant(tolua_S,"Lightning9",MagicSuffixType::Lightning9);
   tolua_constant(tolua_S,"Thunder6",MagicSuffixType::Thunder6);
   tolua_constant(tolua_S,"Storms4",MagicSuffixType::Storms4);
   tolua_constant(tolua_S,"Dexterity12",MagicSuffixType::Dexterity12);
   tolua_constant(tolua_S,"Dexterity13",MagicSuffixType::Dexterity13);
   tolua_constant(tolua_S,"Strength11",MagicSuffixType::Strength11);
   tolua_constant(tolua_S,"Strength12",MagicSuffixType::Strength12);
   tolua_constant(tolua_S,"Thorns3",MagicSuffixType::Thorns3);
   tolua_constant(tolua_S,"Frost8",MagicSuffixType::Frost8);
   tolua_constant(tolua_S,"Flame8",MagicSuffixType::Flame8);
   tolua_constant(tolua_S,"Blight8",MagicSuffixType::Blight8);
   tolua_constant(tolua_S,"Shock8",MagicSuffixType::Shock8);
   tolua_constant(tolua_S,"Regeneration7",MagicSuffixType::Regeneration7);
   tolua_constant(tolua_S,"Energy6",MagicSuffixType::Energy6);
   tolua_constant(tolua_S,"Light3",MagicSuffixType::Light3);
   tolua_constant(tolua_S,"TheLeech5",MagicSuffixType::TheLeech5);
   tolua_constant(tolua_S,"TheLocust4",MagicSuffixType::TheLocust4);
   tolua_constant(tolua_S,"TheLamprey3",MagicSuffixType::TheLamprey3);
   tolua_constant(tolua_S,"TheBat5",MagicSuffixType::TheBat5);
   tolua_constant(tolua_S,"TheWraith3",MagicSuffixType::TheWraith3);
   tolua_constant(tolua_S,"TheVampire4",MagicSuffixType::TheVampire4);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"ItemAffixType",0);
  tolua_beginmodule(tolua_S,"ItemAffixType");
   tolua_constant(tolua_S,"NotApplicable",ItemAffixType::NotApplicable);
   tolua_constant(tolua_S,"Prefix",ItemAffixType::Prefix);
   tolua_constant(tolua_S,"Suffix",ItemAffixType::Suffix);
   tolua_constant(tolua_S,"Inferior",ItemAffixType::Inferior);
   tolua_constant(tolua_S,"InferiorPrefix",ItemAffixType::InferiorPrefix);
   tolua_constant(tolua_S,"Superior",ItemAffixType::Superior);
   tolua_constant(tolua_S,"SuperiorPrefix",ItemAffixType::SuperiorPrefix);
   tolua_constant(tolua_S,"Magic",ItemAffixType::Magic);
   tolua_constant(tolua_S,"MagicPrefix",ItemAffixType::MagicPrefix);
   tolua_constant(tolua_S,"MagicSuffix",ItemAffixType::MagicSuffix);
   tolua_constant(tolua_S,"Rare",ItemAffixType::Rare);
   tolua_constant(tolua_S,"RarePrefix",ItemAffixType::RarePrefix);
   tolua_constant(tolua_S,"RareSuffix",ItemAffixType::RareSuffix);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"BaseStat","BaseStat","",NULL);
  tolua_beginmodule(tolua_S,"BaseStat");
   tolua_variable(tolua_S,"Type",tolua_get_BaseStat_Type,tolua_set_BaseStat_Type);
   tolua_variable(tolua_S,"Index",tolua_get_BaseStat_Index,tolua_set_BaseStat_Index);
   tolua_variable(tolua_S,"TableIndex",tolua_get_BaseStat_TableIndex,tolua_set_BaseStat_TableIndex);
   tolua_variable(tolua_S,"Name",tolua_get_BaseStat_Name,tolua_set_BaseStat_Name);
   tolua_variable(tolua_S,"Stat",tolua_get_BaseStat_Stat,tolua_set_BaseStat_Stat);
   tolua_variable(tolua_S,"SendOther",tolua_get_BaseStat_SendOther,tolua_set_BaseStat_SendOther);
   tolua_variable(tolua_S,"Signed",tolua_get_BaseStat_Signed,tolua_set_BaseStat_Signed);
   tolua_variable(tolua_S,"SendBits",tolua_get_BaseStat_SendBits,tolua_set_BaseStat_SendBits);
   tolua_variable(tolua_S,"SendParamBits",tolua_get_BaseStat_SendParamBits,tolua_set_BaseStat_SendParamBits);
   tolua_variable(tolua_S,"UpdateAnimRate",tolua_get_BaseStat_UpdateAnimRate,tolua_set_BaseStat_UpdateAnimRate);
   tolua_variable(tolua_S,"Saved",tolua_get_BaseStat_Saved,tolua_set_BaseStat_Saved);
   tolua_variable(tolua_S,"CSvSigned",tolua_get_BaseStat_CSvSigned,tolua_set_BaseStat_CSvSigned);
   tolua_variable(tolua_S,"CSvBits",tolua_get_BaseStat_CSvBits,tolua_set_BaseStat_CSvBits);
   tolua_variable(tolua_S,"CSvParam",tolua_get_BaseStat_CSvParam,tolua_set_BaseStat_CSvParam);
   tolua_variable(tolua_S,"fCallback",tolua_get_BaseStat_fCallback,tolua_set_BaseStat_fCallback);
   tolua_variable(tolua_S,"fMin",tolua_get_BaseStat_fMin,tolua_set_BaseStat_fMin);
   tolua_variable(tolua_S,"MinAccr",tolua_get_BaseStat_MinAccr,tolua_set_BaseStat_MinAccr);
   tolua_variable(tolua_S,"Encode",tolua_get_BaseStat_Encode,tolua_set_BaseStat_Encode);
   tolua_variable(tolua_S,"Add",tolua_get_BaseStat_Add,tolua_set_BaseStat_Add);
   tolua_variable(tolua_S,"Multiply",tolua_get_BaseStat_Multiply,tolua_set_BaseStat_Multiply);
   tolua_variable(tolua_S,"Divide",tolua_get_BaseStat_Divide,tolua_set_BaseStat_Divide);
   tolua_variable(tolua_S,"ValShift",tolua_get_BaseStat_ValShift,tolua_set_BaseStat_ValShift);
   tolua_variable(tolua_S,"SaveBits_1_09",tolua_get_BaseStat_SaveBits_1_09,tolua_set_BaseStat_SaveBits_1_09);
   tolua_variable(tolua_S,"SaveAdd_1_09",tolua_get_BaseStat_SaveAdd_1_09,tolua_set_BaseStat_SaveAdd_1_09);
   tolua_variable(tolua_S,"SaveBits",tolua_get_BaseStat_SaveBits,tolua_set_BaseStat_SaveBits);
   tolua_variable(tolua_S,"SaveAdd",tolua_get_BaseStat_SaveAdd,tolua_set_BaseStat_SaveAdd);
   tolua_variable(tolua_S,"SaveParamBits",tolua_get_BaseStat_SaveParamBits,tolua_set_BaseStat_SaveParamBits);
   tolua_variable(tolua_S,"KeepZero",tolua_get_BaseStat_KeepZero,tolua_set_BaseStat_KeepZero);
   tolua_variable(tolua_S,"Op",tolua_get_BaseStat_Op,tolua_set_BaseStat_Op);
   tolua_variable(tolua_S,"OpParam",tolua_get_BaseStat_OpParam,tolua_set_BaseStat_OpParam);
   tolua_variable(tolua_S,"OpBase",tolua_get_BaseStat_OpBase,tolua_set_BaseStat_OpBase);
   tolua_variable(tolua_S,"OpStat1",tolua_get_BaseStat_OpStat1,tolua_set_BaseStat_OpStat1);
   tolua_variable(tolua_S,"OpStat2",tolua_get_BaseStat_OpStat2,tolua_set_BaseStat_OpStat2);
   tolua_variable(tolua_S,"OpStat3",tolua_get_BaseStat_OpStat3,tolua_set_BaseStat_OpStat3);
   tolua_variable(tolua_S,"Direct",tolua_get_BaseStat_Direct,tolua_set_BaseStat_Direct);
   tolua_variable(tolua_S,"MaxStat",tolua_get_BaseStat_MaxStat,tolua_set_BaseStat_MaxStat);
   tolua_variable(tolua_S,"ItemSpecific",tolua_get_BaseStat_ItemSpecific,tolua_set_BaseStat_ItemSpecific);
   tolua_variable(tolua_S,"DamageRelated",tolua_get_BaseStat_DamageRelated,tolua_set_BaseStat_DamageRelated);
   tolua_variable(tolua_S,"ItemEvent1",tolua_get_BaseStat_ItemEvent1,tolua_set_BaseStat_ItemEvent1);
   tolua_variable(tolua_S,"ItemEventFunc1",tolua_get_BaseStat_ItemEventFunc1,tolua_set_BaseStat_ItemEventFunc1);
   tolua_variable(tolua_S,"ItemEvent2",tolua_get_BaseStat_ItemEvent2,tolua_set_BaseStat_ItemEvent2);
   tolua_variable(tolua_S,"ItemEventFunc2",tolua_get_BaseStat_ItemEventFunc2,tolua_set_BaseStat_ItemEventFunc2);
   tolua_variable(tolua_S,"DescPriority",tolua_get_BaseStat_DescPriority,tolua_set_BaseStat_DescPriority);
   tolua_variable(tolua_S,"DescFunc",tolua_get_BaseStat_DescFunc,tolua_set_BaseStat_DescFunc);
   tolua_variable(tolua_S,"DescVal",tolua_get_BaseStat_DescVal,tolua_set_BaseStat_DescVal);
   tolua_variable(tolua_S,"DescStrPos",tolua_get_BaseStat_DescStrPos,tolua_set_BaseStat_DescStrPos);
   tolua_variable(tolua_S,"DescStrNeg",tolua_get_BaseStat_DescStrNeg,tolua_set_BaseStat_DescStrNeg);
   tolua_variable(tolua_S,"DescStr2",tolua_get_BaseStat_DescStr2,tolua_set_BaseStat_DescStr2);
   tolua_variable(tolua_S,"DGrp",tolua_get_BaseStat_DGrp,tolua_set_BaseStat_DGrp);
   tolua_variable(tolua_S,"DGrpFunc",tolua_get_BaseStat_DGrpFunc,tolua_set_BaseStat_DGrpFunc);
   tolua_variable(tolua_S,"DGrpval",tolua_get_BaseStat_DGrpval,tolua_set_BaseStat_DGrpval);
   tolua_variable(tolua_S,"DGrpStrPos",tolua_get_BaseStat_DGrpStrPos,tolua_set_BaseStat_DGrpStrPos);
   tolua_variable(tolua_S,"DGrpStrNeg",tolua_get_BaseStat_DGrpStrNeg,tolua_set_BaseStat_DGrpStrNeg);
   tolua_variable(tolua_S,"DGrpStr2",tolua_get_BaseStat_DGrpStr2,tolua_set_BaseStat_DGrpStr2);
   tolua_variable(tolua_S,"Stuff",tolua_get_BaseStat_Stuff,tolua_set_BaseStat_Stuff);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"StatBase","StatBase","",tolua_collect_StatBase);
  #else
  tolua_cclass(tolua_S,"StatBase","StatBase","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"StatBase");
   tolua_variable(tolua_S,"Stat",tolua_get_StatBase_Stat_ptr,tolua_set_StatBase_Stat_ptr);
   tolua_variable(tolua_S,"Value",tolua_get_StatBase_unsigned_Value,tolua_set_StatBase_unsigned_Value);
   tolua_variable(tolua_S,"Param",tolua_get_StatBase_unsigned_Param,tolua_set_StatBase_unsigned_Param);
   tolua_variable(tolua_S,"Skill",tolua_get_StatBase_Skill,tolua_set_StatBase_Skill);
   tolua_variable(tolua_S,"Monster",tolua_get_StatBase_Monster,tolua_set_StatBase_Monster);
   tolua_variable(tolua_S,"Charges",tolua_get_StatBase_Charges,tolua_set_StatBase_Charges);
   tolua_variable(tolua_S,"MaxCharges",tolua_get_StatBase_MaxCharges,tolua_set_StatBase_MaxCharges);
   tolua_variable(tolua_S,"Chance",tolua_get_StatBase_Chance,tolua_set_StatBase_Chance);
   tolua_variable(tolua_S,"Event",tolua_get_StatBase_Event,tolua_set_StatBase_Event);
   tolua_variable(tolua_S,"Element",tolua_get_StatBase_Element,tolua_set_StatBase_Element);
   tolua_variable(tolua_S,"Class",tolua_get_StatBase_Class,tolua_set_StatBase_Class);
   tolua_variable(tolua_S,"Tab",tolua_get_StatBase_Tab,tolua_set_StatBase_Tab);
   tolua_variable(tolua_S,"TabNumber",tolua_get_StatBase_TabNumber,tolua_set_StatBase_TabNumber);
   tolua_variable(tolua_S,"Unknown",tolua_get_StatBase_Unknown,tolua_set_StatBase_Unknown);
   tolua_variable(tolua_S,"PerLevel",tolua_get_StatBase_PerLevel,tolua_set_StatBase_PerLevel);
   tolua_variable(tolua_S,"Type",tolua_get_StatBase_Type,tolua_set_StatBase_Type);
   tolua_variable(tolua_S,"IsPercent",tolua_get_StatBase_IsPercent,tolua_set_StatBase_IsPercent);
   tolua_variable(tolua_S,"Frames",tolua_get_StatBase_Frames,tolua_set_StatBase_Frames);
   tolua_variable(tolua_S,"Seconds",tolua_get_StatBase_Seconds,tolua_set_StatBase_Seconds);
   tolua_variable(tolua_S,"Min",tolua_get_StatBase_Min,tolua_set_StatBase_Min);
   tolua_variable(tolua_S,"Max",tolua_get_StatBase_Max,tolua_set_StatBase_Max);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ItemNames","ItemNames","",NULL);
  tolua_beginmodule(tolua_S,"ItemNames");
   tolua_variable(tolua_S,"SuperiorPrefix",tolua_get_ItemNames_SuperiorPrefix,NULL);
   tolua_array(tolua_S,"InferiorPrefix",tolua_get_item_ItemNames_InferiorPrefix,NULL);
   tolua_variable(tolua_S,"RarePrefixOffset",tolua_get_ItemNames_RarePrefixOffset,NULL);
   tolua_variable(tolua_S,"RareSuffixOffset",tolua_get_ItemNames_RareSuffixOffset,NULL);
   tolua_array(tolua_S,"RareAffix",tolua_get_item_ItemNames_RareAffix,NULL);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ItemAffix","ItemAffix","",NULL);
  tolua_beginmodule(tolua_S,"ItemAffix");
   tolua_variable(tolua_S,"Type",tolua_get_ItemAffix_Type,tolua_set_ItemAffix_Type);
   tolua_variable(tolua_S,"Index",tolua_get_ItemAffix_Index,tolua_set_ItemAffix_Index);
   tolua_variable(tolua_S,"Name",tolua_get_ItemAffix_Name,tolua_set_ItemAffix_Name);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"BaseProperty","BaseProperty","",NULL);
  tolua_beginmodule(tolua_S,"BaseProperty");
   tolua_variable(tolua_S,"Index",tolua_get_BaseProperty_Index,tolua_set_BaseProperty_Index);
   tolua_variable(tolua_S,"Code",tolua_get_BaseProperty_Code,tolua_set_BaseProperty_Code);
   tolua_variable(tolua_S,"Done",tolua_get_BaseProperty_Done,tolua_set_BaseProperty_Done);
   tolua_variable(tolua_S,"Set1",tolua_get_BaseProperty_Set1,tolua_set_BaseProperty_Set1);
   tolua_variable(tolua_S,"Val1",tolua_get_BaseProperty_Val1,tolua_set_BaseProperty_Val1);
   tolua_variable(tolua_S,"Func1",tolua_get_BaseProperty_Func1,tolua_set_BaseProperty_Func1);
   tolua_variable(tolua_S,"Stat1",tolua_get_BaseProperty_Stat1,tolua_set_BaseProperty_Stat1);
   tolua_variable(tolua_S,"Set2",tolua_get_BaseProperty_Set2,tolua_set_BaseProperty_Set2);
   tolua_variable(tolua_S,"Val2",tolua_get_BaseProperty_Val2,tolua_set_BaseProperty_Val2);
   tolua_variable(tolua_S,"Func2",tolua_get_BaseProperty_Func2,tolua_set_BaseProperty_Func2);
   tolua_variable(tolua_S,"Stat2",tolua_get_BaseProperty_Stat2,tolua_set_BaseProperty_Stat2);
   tolua_variable(tolua_S,"Set3",tolua_get_BaseProperty_Set3,tolua_set_BaseProperty_Set3);
   tolua_variable(tolua_S,"Val3",tolua_get_BaseProperty_Val3,tolua_set_BaseProperty_Val3);
   tolua_variable(tolua_S,"Func3",tolua_get_BaseProperty_Func3,tolua_set_BaseProperty_Func3);
   tolua_variable(tolua_S,"Stat3",tolua_get_BaseProperty_Stat3,tolua_set_BaseProperty_Stat3);
   tolua_variable(tolua_S,"Set4",tolua_get_BaseProperty_Set4,tolua_set_BaseProperty_Set4);
   tolua_variable(tolua_S,"Val4",tolua_get_BaseProperty_Val4,tolua_set_BaseProperty_Val4);
   tolua_variable(tolua_S,"Func4",tolua_get_BaseProperty_Func4,tolua_set_BaseProperty_Func4);
   tolua_variable(tolua_S,"Stat4",tolua_get_BaseProperty_Stat4,tolua_set_BaseProperty_Stat4);
   tolua_variable(tolua_S,"Set5",tolua_get_BaseProperty_Set5,tolua_set_BaseProperty_Set5);
   tolua_variable(tolua_S,"Val5",tolua_get_BaseProperty_Val5,tolua_set_BaseProperty_Val5);
   tolua_variable(tolua_S,"Func5",tolua_get_BaseProperty_Func5,tolua_set_BaseProperty_Func5);
   tolua_variable(tolua_S,"Stat5",tolua_get_BaseProperty_Stat5,tolua_set_BaseProperty_Stat5);
   tolua_variable(tolua_S,"Set6",tolua_get_BaseProperty_Set6,tolua_set_BaseProperty_Set6);
   tolua_variable(tolua_S,"Val6",tolua_get_BaseProperty_Val6,tolua_set_BaseProperty_Val6);
   tolua_variable(tolua_S,"Func6",tolua_get_BaseProperty_Func6,tolua_set_BaseProperty_Func6);
   tolua_variable(tolua_S,"Stat6",tolua_get_BaseProperty_Stat6,tolua_set_BaseProperty_Stat6);
   tolua_variable(tolua_S,"Set7",tolua_get_BaseProperty_Set7,tolua_set_BaseProperty_Set7);
   tolua_variable(tolua_S,"Val7",tolua_get_BaseProperty_Val7,tolua_set_BaseProperty_Val7);
   tolua_variable(tolua_S,"Func7",tolua_get_BaseProperty_Func7,tolua_set_BaseProperty_Func7);
   tolua_variable(tolua_S,"Stat7",tolua_get_BaseProperty_Stat7,tolua_set_BaseProperty_Stat7);
   tolua_variable(tolua_S,"Desc",tolua_get_BaseProperty_Desc,tolua_set_BaseProperty_Desc);
   tolua_variable(tolua_S,"Param",tolua_get_BaseProperty_Param,tolua_set_BaseProperty_Param);
   tolua_variable(tolua_S,"Min",tolua_get_BaseProperty_Min,tolua_set_BaseProperty_Min);
   tolua_variable(tolua_S,"Max",tolua_get_BaseProperty_Max,tolua_set_BaseProperty_Max);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"BaseRuneword","BaseRuneword","",NULL);
  tolua_beginmodule(tolua_S,"BaseRuneword");
   tolua_variable(tolua_S,"Index",tolua_get_BaseRuneword_Index,tolua_set_BaseRuneword_Index);
   tolua_variable(tolua_S,"Id",tolua_get_BaseRuneword_Id,tolua_set_BaseRuneword_Id);
   tolua_variable(tolua_S,"Name",tolua_get_BaseRuneword_Name,tolua_set_BaseRuneword_Name);
   tolua_variable(tolua_S,"Complete",tolua_get_BaseRuneword_Complete,tolua_set_BaseRuneword_Complete);
   tolua_variable(tolua_S,"Server",tolua_get_BaseRuneword_Server,tolua_set_BaseRuneword_Server);
   tolua_variable(tolua_S,"IType1",tolua_get_BaseRuneword_IType1_ptr,tolua_set_BaseRuneword_IType1_ptr);
   tolua_variable(tolua_S,"IType2",tolua_get_BaseRuneword_IType2_ptr,tolua_set_BaseRuneword_IType2_ptr);
   tolua_variable(tolua_S,"IType3",tolua_get_BaseRuneword_IType3_ptr,tolua_set_BaseRuneword_IType3_ptr);
   tolua_variable(tolua_S,"IType4",tolua_get_BaseRuneword_IType4_ptr,tolua_set_BaseRuneword_IType4_ptr);
   tolua_variable(tolua_S,"IType5",tolua_get_BaseRuneword_IType5_ptr,tolua_set_BaseRuneword_IType5_ptr);
   tolua_variable(tolua_S,"IType6",tolua_get_BaseRuneword_IType6_ptr,tolua_set_BaseRuneword_IType6_ptr);
   tolua_variable(tolua_S,"EType1",tolua_get_BaseRuneword_EType1_ptr,tolua_set_BaseRuneword_EType1_ptr);
   tolua_variable(tolua_S,"EType2",tolua_get_BaseRuneword_EType2_ptr,tolua_set_BaseRuneword_EType2_ptr);
   tolua_variable(tolua_S,"EType3",tolua_get_BaseRuneword_EType3_ptr,tolua_set_BaseRuneword_EType3_ptr);
   tolua_variable(tolua_S,"Runes",tolua_get_BaseRuneword_Runes,tolua_set_BaseRuneword_Runes);
   tolua_variable(tolua_S,"Rune1",tolua_get_BaseRuneword_Rune1,tolua_set_BaseRuneword_Rune1);
   tolua_variable(tolua_S,"Rune2",tolua_get_BaseRuneword_Rune2,tolua_set_BaseRuneword_Rune2);
   tolua_variable(tolua_S,"Rune3",tolua_get_BaseRuneword_Rune3,tolua_set_BaseRuneword_Rune3);
   tolua_variable(tolua_S,"Rune4",tolua_get_BaseRuneword_Rune4,tolua_set_BaseRuneword_Rune4);
   tolua_variable(tolua_S,"Rune5",tolua_get_BaseRuneword_Rune5,tolua_set_BaseRuneword_Rune5);
   tolua_variable(tolua_S,"Rune6",tolua_get_BaseRuneword_Rune6,tolua_set_BaseRuneword_Rune6);
   tolua_variable(tolua_S,"Property1",tolua_get_BaseRuneword_Property1_ptr,tolua_set_BaseRuneword_Property1_ptr);
   tolua_variable(tolua_S,"Param1",tolua_get_BaseRuneword_Param1,tolua_set_BaseRuneword_Param1);
   tolua_variable(tolua_S,"Min1",tolua_get_BaseRuneword_Min1,tolua_set_BaseRuneword_Min1);
   tolua_variable(tolua_S,"Max1",tolua_get_BaseRuneword_Max1,tolua_set_BaseRuneword_Max1);
   tolua_variable(tolua_S,"Property2",tolua_get_BaseRuneword_Property2_ptr,tolua_set_BaseRuneword_Property2_ptr);
   tolua_variable(tolua_S,"Param2",tolua_get_BaseRuneword_Param2,tolua_set_BaseRuneword_Param2);
   tolua_variable(tolua_S,"Min2",tolua_get_BaseRuneword_Min2,tolua_set_BaseRuneword_Min2);
   tolua_variable(tolua_S,"Max2",tolua_get_BaseRuneword_Max2,tolua_set_BaseRuneword_Max2);
   tolua_variable(tolua_S,"Property3",tolua_get_BaseRuneword_Property3_ptr,tolua_set_BaseRuneword_Property3_ptr);
   tolua_variable(tolua_S,"Param3",tolua_get_BaseRuneword_Param3,tolua_set_BaseRuneword_Param3);
   tolua_variable(tolua_S,"Min3",tolua_get_BaseRuneword_Min3,tolua_set_BaseRuneword_Min3);
   tolua_variable(tolua_S,"Max3",tolua_get_BaseRuneword_Max3,tolua_set_BaseRuneword_Max3);
   tolua_variable(tolua_S,"Property4",tolua_get_BaseRuneword_Property4_ptr,tolua_set_BaseRuneword_Property4_ptr);
   tolua_variable(tolua_S,"Param4",tolua_get_BaseRuneword_Param4,tolua_set_BaseRuneword_Param4);
   tolua_variable(tolua_S,"Min4",tolua_get_BaseRuneword_Min4,tolua_set_BaseRuneword_Min4);
   tolua_variable(tolua_S,"Max4",tolua_get_BaseRuneword_Max4,tolua_set_BaseRuneword_Max4);
   tolua_variable(tolua_S,"Property5",tolua_get_BaseRuneword_Property5_ptr,tolua_set_BaseRuneword_Property5_ptr);
   tolua_variable(tolua_S,"Param5",tolua_get_BaseRuneword_Param5,tolua_set_BaseRuneword_Param5);
   tolua_variable(tolua_S,"Min5",tolua_get_BaseRuneword_Min5,tolua_set_BaseRuneword_Min5);
   tolua_variable(tolua_S,"Max5",tolua_get_BaseRuneword_Max5,tolua_set_BaseRuneword_Max5);
   tolua_variable(tolua_S,"Property6",tolua_get_BaseRuneword_Property6_ptr,tolua_set_BaseRuneword_Property6_ptr);
   tolua_variable(tolua_S,"Param6",tolua_get_BaseRuneword_Param6,tolua_set_BaseRuneword_Param6);
   tolua_variable(tolua_S,"Min6",tolua_get_BaseRuneword_Min6,tolua_set_BaseRuneword_Min6);
   tolua_variable(tolua_S,"Max6",tolua_get_BaseRuneword_Max6,tolua_set_BaseRuneword_Max6);
   tolua_variable(tolua_S,"Property7",tolua_get_BaseRuneword_Property7_ptr,tolua_set_BaseRuneword_Property7_ptr);
   tolua_variable(tolua_S,"Param7",tolua_get_BaseRuneword_Param7,tolua_set_BaseRuneword_Param7);
   tolua_variable(tolua_S,"Min7",tolua_get_BaseRuneword_Min7,tolua_set_BaseRuneword_Min7);
   tolua_variable(tolua_S,"Max7",tolua_get_BaseRuneword_Max7,tolua_set_BaseRuneword_Max7);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"BaseUniqueItem","BaseUniqueItem","",NULL);
  tolua_beginmodule(tolua_S,"BaseUniqueItem");
   tolua_variable(tolua_S,"Index",tolua_get_BaseUniqueItem_Index,tolua_set_BaseUniqueItem_Index);
   tolua_variable(tolua_S,"Id",tolua_get_BaseUniqueItem_Id,tolua_set_BaseUniqueItem_Id);
   tolua_variable(tolua_S,"Name",tolua_get_BaseUniqueItem_Name,tolua_set_BaseUniqueItem_Name);
   tolua_variable(tolua_S,"Item",tolua_get_BaseUniqueItem_Item_ptr,tolua_set_BaseUniqueItem_Item_ptr);
   tolua_variable(tolua_S,"Version",tolua_get_BaseUniqueItem_Version,tolua_set_BaseUniqueItem_Version);
   tolua_variable(tolua_S,"Enabled",tolua_get_BaseUniqueItem_Enabled,tolua_set_BaseUniqueItem_Enabled);
   tolua_variable(tolua_S,"Ladder",tolua_get_BaseUniqueItem_Ladder,tolua_set_BaseUniqueItem_Ladder);
   tolua_variable(tolua_S,"Rarity",tolua_get_BaseUniqueItem_Rarity,tolua_set_BaseUniqueItem_Rarity);
   tolua_variable(tolua_S,"NoLimit",tolua_get_BaseUniqueItem_NoLimit,tolua_set_BaseUniqueItem_NoLimit);
   tolua_variable(tolua_S,"DropLevel",tolua_get_BaseUniqueItem_DropLevel,tolua_set_BaseUniqueItem_DropLevel);
   tolua_variable(tolua_S,"RequiredLevel",tolua_get_BaseUniqueItem_RequiredLevel,tolua_set_BaseUniqueItem_RequiredLevel);
   tolua_variable(tolua_S,"BaseItemName",tolua_get_BaseUniqueItem_BaseItemName,tolua_set_BaseUniqueItem_BaseItemName);
   tolua_variable(tolua_S,"Uber",tolua_get_BaseUniqueItem_Uber,tolua_set_BaseUniqueItem_Uber);
   tolua_variable(tolua_S,"Carry1",tolua_get_BaseUniqueItem_Carry1,tolua_set_BaseUniqueItem_Carry1);
   tolua_variable(tolua_S,"CostMultiply",tolua_get_BaseUniqueItem_CostMultiply,tolua_set_BaseUniqueItem_CostMultiply);
   tolua_variable(tolua_S,"CostAdd",tolua_get_BaseUniqueItem_CostAdd,tolua_set_BaseUniqueItem_CostAdd);
   tolua_variable(tolua_S,"CharTransform",tolua_get_BaseUniqueItem_CharTransform,tolua_set_BaseUniqueItem_CharTransform);
   tolua_variable(tolua_S,"InvTransform",tolua_get_BaseUniqueItem_InvTransform,tolua_set_BaseUniqueItem_InvTransform);
   tolua_variable(tolua_S,"FlippyFile",tolua_get_BaseUniqueItem_FlippyFile,tolua_set_BaseUniqueItem_FlippyFile);
   tolua_variable(tolua_S,"InvFile",tolua_get_BaseUniqueItem_InvFile,tolua_set_BaseUniqueItem_InvFile);
   tolua_variable(tolua_S,"DropSound",tolua_get_BaseUniqueItem_DropSound,tolua_set_BaseUniqueItem_DropSound);
   tolua_variable(tolua_S,"DropSfxFrame",tolua_get_BaseUniqueItem_DropSfxFrame,tolua_set_BaseUniqueItem_DropSfxFrame);
   tolua_variable(tolua_S,"UseSound",tolua_get_BaseUniqueItem_UseSound,tolua_set_BaseUniqueItem_UseSound);
   tolua_variable(tolua_S,"Property1",tolua_get_BaseUniqueItem_Property1_ptr,tolua_set_BaseUniqueItem_Property1_ptr);
   tolua_variable(tolua_S,"Param1",tolua_get_BaseUniqueItem_Param1,tolua_set_BaseUniqueItem_Param1);
   tolua_variable(tolua_S,"Min1",tolua_get_BaseUniqueItem_Min1,tolua_set_BaseUniqueItem_Min1);
   tolua_variable(tolua_S,"Max1",tolua_get_BaseUniqueItem_Max1,tolua_set_BaseUniqueItem_Max1);
   tolua_variable(tolua_S,"Property2",tolua_get_BaseUniqueItem_Property2_ptr,tolua_set_BaseUniqueItem_Property2_ptr);
   tolua_variable(tolua_S,"Param2",tolua_get_BaseUniqueItem_Param2,tolua_set_BaseUniqueItem_Param2);
   tolua_variable(tolua_S,"Min2",tolua_get_BaseUniqueItem_Min2,tolua_set_BaseUniqueItem_Min2);
   tolua_variable(tolua_S,"Max2",tolua_get_BaseUniqueItem_Max2,tolua_set_BaseUniqueItem_Max2);
   tolua_variable(tolua_S,"Property3",tolua_get_BaseUniqueItem_Property3_ptr,tolua_set_BaseUniqueItem_Property3_ptr);
   tolua_variable(tolua_S,"Param3",tolua_get_BaseUniqueItem_Param3,tolua_set_BaseUniqueItem_Param3);
   tolua_variable(tolua_S,"Min3",tolua_get_BaseUniqueItem_Min3,tolua_set_BaseUniqueItem_Min3);
   tolua_variable(tolua_S,"Max3",tolua_get_BaseUniqueItem_Max3,tolua_set_BaseUniqueItem_Max3);
   tolua_variable(tolua_S,"Property4",tolua_get_BaseUniqueItem_Property4_ptr,tolua_set_BaseUniqueItem_Property4_ptr);
   tolua_variable(tolua_S,"Param4",tolua_get_BaseUniqueItem_Param4,tolua_set_BaseUniqueItem_Param4);
   tolua_variable(tolua_S,"Min4",tolua_get_BaseUniqueItem_Min4,tolua_set_BaseUniqueItem_Min4);
   tolua_variable(tolua_S,"Max4",tolua_get_BaseUniqueItem_Max4,tolua_set_BaseUniqueItem_Max4);
   tolua_variable(tolua_S,"Property5",tolua_get_BaseUniqueItem_Property5_ptr,tolua_set_BaseUniqueItem_Property5_ptr);
   tolua_variable(tolua_S,"Param5",tolua_get_BaseUniqueItem_Param5,tolua_set_BaseUniqueItem_Param5);
   tolua_variable(tolua_S,"Min5",tolua_get_BaseUniqueItem_Min5,tolua_set_BaseUniqueItem_Min5);
   tolua_variable(tolua_S,"Max5",tolua_get_BaseUniqueItem_Max5,tolua_set_BaseUniqueItem_Max5);
   tolua_variable(tolua_S,"Property6",tolua_get_BaseUniqueItem_Property6_ptr,tolua_set_BaseUniqueItem_Property6_ptr);
   tolua_variable(tolua_S,"Param6",tolua_get_BaseUniqueItem_Param6,tolua_set_BaseUniqueItem_Param6);
   tolua_variable(tolua_S,"Min6",tolua_get_BaseUniqueItem_Min6,tolua_set_BaseUniqueItem_Min6);
   tolua_variable(tolua_S,"Max6",tolua_get_BaseUniqueItem_Max6,tolua_set_BaseUniqueItem_Max6);
   tolua_variable(tolua_S,"Property7",tolua_get_BaseUniqueItem_Property7_ptr,tolua_set_BaseUniqueItem_Property7_ptr);
   tolua_variable(tolua_S,"Param7",tolua_get_BaseUniqueItem_Param7,tolua_set_BaseUniqueItem_Param7);
   tolua_variable(tolua_S,"Min7",tolua_get_BaseUniqueItem_Min7,tolua_set_BaseUniqueItem_Min7);
   tolua_variable(tolua_S,"Max7",tolua_get_BaseUniqueItem_Max7,tolua_set_BaseUniqueItem_Max7);
   tolua_variable(tolua_S,"Property8",tolua_get_BaseUniqueItem_Property8_ptr,tolua_set_BaseUniqueItem_Property8_ptr);
   tolua_variable(tolua_S,"Param8",tolua_get_BaseUniqueItem_Param8,tolua_set_BaseUniqueItem_Param8);
   tolua_variable(tolua_S,"Min8",tolua_get_BaseUniqueItem_Min8,tolua_set_BaseUniqueItem_Min8);
   tolua_variable(tolua_S,"Max8",tolua_get_BaseUniqueItem_Max8,tolua_set_BaseUniqueItem_Max8);
   tolua_variable(tolua_S,"Property9",tolua_get_BaseUniqueItem_Property9_ptr,tolua_set_BaseUniqueItem_Property9_ptr);
   tolua_variable(tolua_S,"Param9",tolua_get_BaseUniqueItem_Param9,tolua_set_BaseUniqueItem_Param9);
   tolua_variable(tolua_S,"Min9",tolua_get_BaseUniqueItem_Min9,tolua_set_BaseUniqueItem_Min9);
   tolua_variable(tolua_S,"Max9",tolua_get_BaseUniqueItem_Max9,tolua_set_BaseUniqueItem_Max9);
   tolua_variable(tolua_S,"Property10",tolua_get_BaseUniqueItem_Property10_ptr,tolua_set_BaseUniqueItem_Property10_ptr);
   tolua_variable(tolua_S,"Param10",tolua_get_BaseUniqueItem_Param10,tolua_set_BaseUniqueItem_Param10);
   tolua_variable(tolua_S,"Min10",tolua_get_BaseUniqueItem_Min10,tolua_set_BaseUniqueItem_Min10);
   tolua_variable(tolua_S,"Max10",tolua_get_BaseUniqueItem_Max10,tolua_set_BaseUniqueItem_Max10);
   tolua_variable(tolua_S,"Property11",tolua_get_BaseUniqueItem_Property11_ptr,tolua_set_BaseUniqueItem_Property11_ptr);
   tolua_variable(tolua_S,"Param11",tolua_get_BaseUniqueItem_Param11,tolua_set_BaseUniqueItem_Param11);
   tolua_variable(tolua_S,"Min11",tolua_get_BaseUniqueItem_Min11,tolua_set_BaseUniqueItem_Min11);
   tolua_variable(tolua_S,"Max11",tolua_get_BaseUniqueItem_Max11,tolua_set_BaseUniqueItem_Max11);
   tolua_variable(tolua_S,"Property12",tolua_get_BaseUniqueItem_Property12_ptr,tolua_set_BaseUniqueItem_Property12_ptr);
   tolua_variable(tolua_S,"Param12",tolua_get_BaseUniqueItem_Param12,tolua_set_BaseUniqueItem_Param12);
   tolua_variable(tolua_S,"Min12",tolua_get_BaseUniqueItem_Min12,tolua_set_BaseUniqueItem_Min12);
   tolua_variable(tolua_S,"Max12",tolua_get_BaseUniqueItem_Max12,tolua_set_BaseUniqueItem_Max12);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ItemSet","ItemSet","",NULL);
  tolua_beginmodule(tolua_S,"ItemSet");
   tolua_variable(tolua_S,"Index",tolua_get_ItemSet_Index,tolua_set_ItemSet_Index);
   tolua_variable(tolua_S,"Id",tolua_get_ItemSet_Id,tolua_set_ItemSet_Id);
   tolua_variable(tolua_S,"Name",tolua_get_ItemSet_Name,tolua_set_ItemSet_Name);
   tolua_variable(tolua_S,"Name2",tolua_get_ItemSet_Name2,tolua_set_ItemSet_Name2);
   tolua_variable(tolua_S,"Version",tolua_get_ItemSet_Version,tolua_set_ItemSet_Version);
   tolua_variable(tolua_S,"Level",tolua_get_ItemSet_Level,tolua_set_ItemSet_Level);
   tolua_variable(tolua_S,"PCode2a",tolua_get_ItemSet_PCode2a,tolua_set_ItemSet_PCode2a);
   tolua_variable(tolua_S,"PParam2a",tolua_get_ItemSet_PParam2a,tolua_set_ItemSet_PParam2a);
   tolua_variable(tolua_S,"PMin2a",tolua_get_ItemSet_PMin2a,tolua_set_ItemSet_PMin2a);
   tolua_variable(tolua_S,"PMax2a",tolua_get_ItemSet_PMax2a,tolua_set_ItemSet_PMax2a);
   tolua_variable(tolua_S,"PCode2b",tolua_get_ItemSet_PCode2b,tolua_set_ItemSet_PCode2b);
   tolua_variable(tolua_S,"PParam2b",tolua_get_ItemSet_PParam2b,tolua_set_ItemSet_PParam2b);
   tolua_variable(tolua_S,"PMin2b",tolua_get_ItemSet_PMin2b,tolua_set_ItemSet_PMin2b);
   tolua_variable(tolua_S,"PMax2b",tolua_get_ItemSet_PMax2b,tolua_set_ItemSet_PMax2b);
   tolua_variable(tolua_S,"PCode3a",tolua_get_ItemSet_PCode3a,tolua_set_ItemSet_PCode3a);
   tolua_variable(tolua_S,"PParam3a",tolua_get_ItemSet_PParam3a,tolua_set_ItemSet_PParam3a);
   tolua_variable(tolua_S,"PMin3a",tolua_get_ItemSet_PMin3a,tolua_set_ItemSet_PMin3a);
   tolua_variable(tolua_S,"PMax3a",tolua_get_ItemSet_PMax3a,tolua_set_ItemSet_PMax3a);
   tolua_variable(tolua_S,"PCode3b",tolua_get_ItemSet_PCode3b,tolua_set_ItemSet_PCode3b);
   tolua_variable(tolua_S,"PParam3b",tolua_get_ItemSet_PParam3b,tolua_set_ItemSet_PParam3b);
   tolua_variable(tolua_S,"PMin3b",tolua_get_ItemSet_PMin3b,tolua_set_ItemSet_PMin3b);
   tolua_variable(tolua_S,"PMax3b",tolua_get_ItemSet_PMax3b,tolua_set_ItemSet_PMax3b);
   tolua_variable(tolua_S,"PCode4a",tolua_get_ItemSet_PCode4a,tolua_set_ItemSet_PCode4a);
   tolua_variable(tolua_S,"PParam4a",tolua_get_ItemSet_PParam4a,tolua_set_ItemSet_PParam4a);
   tolua_variable(tolua_S,"PMin4a",tolua_get_ItemSet_PMin4a,tolua_set_ItemSet_PMin4a);
   tolua_variable(tolua_S,"PMax4a",tolua_get_ItemSet_PMax4a,tolua_set_ItemSet_PMax4a);
   tolua_variable(tolua_S,"PCode4b",tolua_get_ItemSet_PCode4b,tolua_set_ItemSet_PCode4b);
   tolua_variable(tolua_S,"PParam4b",tolua_get_ItemSet_PParam4b,tolua_set_ItemSet_PParam4b);
   tolua_variable(tolua_S,"PMin4b",tolua_get_ItemSet_PMin4b,tolua_set_ItemSet_PMin4b);
   tolua_variable(tolua_S,"PMax4b",tolua_get_ItemSet_PMax4b,tolua_set_ItemSet_PMax4b);
   tolua_variable(tolua_S,"PCode5a",tolua_get_ItemSet_PCode5a,tolua_set_ItemSet_PCode5a);
   tolua_variable(tolua_S,"PParam5a",tolua_get_ItemSet_PParam5a,tolua_set_ItemSet_PParam5a);
   tolua_variable(tolua_S,"PMin5a",tolua_get_ItemSet_PMin5a,tolua_set_ItemSet_PMin5a);
   tolua_variable(tolua_S,"PMax5a",tolua_get_ItemSet_PMax5a,tolua_set_ItemSet_PMax5a);
   tolua_variable(tolua_S,"PCode5b",tolua_get_ItemSet_PCode5b,tolua_set_ItemSet_PCode5b);
   tolua_variable(tolua_S,"PParam5b",tolua_get_ItemSet_PParam5b,tolua_set_ItemSet_PParam5b);
   tolua_variable(tolua_S,"PMin5b",tolua_get_ItemSet_PMin5b,tolua_set_ItemSet_PMin5b);
   tolua_variable(tolua_S,"PMax5b",tolua_get_ItemSet_PMax5b,tolua_set_ItemSet_PMax5b);
   tolua_variable(tolua_S,"FCode1",tolua_get_ItemSet_FCode1,tolua_set_ItemSet_FCode1);
   tolua_variable(tolua_S,"FParam1",tolua_get_ItemSet_FParam1,tolua_set_ItemSet_FParam1);
   tolua_variable(tolua_S,"FMin1",tolua_get_ItemSet_FMin1,tolua_set_ItemSet_FMin1);
   tolua_variable(tolua_S,"FMax1",tolua_get_ItemSet_FMax1,tolua_set_ItemSet_FMax1);
   tolua_variable(tolua_S,"FCode2",tolua_get_ItemSet_FCode2,tolua_set_ItemSet_FCode2);
   tolua_variable(tolua_S,"FParam2",tolua_get_ItemSet_FParam2,tolua_set_ItemSet_FParam2);
   tolua_variable(tolua_S,"FMin2",tolua_get_ItemSet_FMin2,tolua_set_ItemSet_FMin2);
   tolua_variable(tolua_S,"FMax2",tolua_get_ItemSet_FMax2,tolua_set_ItemSet_FMax2);
   tolua_variable(tolua_S,"FCode3",tolua_get_ItemSet_FCode3,tolua_set_ItemSet_FCode3);
   tolua_variable(tolua_S,"FParam3",tolua_get_ItemSet_FParam3,tolua_set_ItemSet_FParam3);
   tolua_variable(tolua_S,"FMin3",tolua_get_ItemSet_FMin3,tolua_set_ItemSet_FMin3);
   tolua_variable(tolua_S,"FMax3",tolua_get_ItemSet_FMax3,tolua_set_ItemSet_FMax3);
   tolua_variable(tolua_S,"FCode4",tolua_get_ItemSet_FCode4,tolua_set_ItemSet_FCode4);
   tolua_variable(tolua_S,"FParam4",tolua_get_ItemSet_FParam4,tolua_set_ItemSet_FParam4);
   tolua_variable(tolua_S,"FMin4",tolua_get_ItemSet_FMin4,tolua_set_ItemSet_FMin4);
   tolua_variable(tolua_S,"FMax4",tolua_get_ItemSet_FMax4,tolua_set_ItemSet_FMax4);
   tolua_variable(tolua_S,"FCode5",tolua_get_ItemSet_FCode5,tolua_set_ItemSet_FCode5);
   tolua_variable(tolua_S,"FParam5",tolua_get_ItemSet_FParam5,tolua_set_ItemSet_FParam5);
   tolua_variable(tolua_S,"FMin5",tolua_get_ItemSet_FMin5,tolua_set_ItemSet_FMin5);
   tolua_variable(tolua_S,"FMax5",tolua_get_ItemSet_FMax5,tolua_set_ItemSet_FMax5);
   tolua_variable(tolua_S,"FCode6",tolua_get_ItemSet_FCode6,tolua_set_ItemSet_FCode6);
   tolua_variable(tolua_S,"FParam6",tolua_get_ItemSet_FParam6,tolua_set_ItemSet_FParam6);
   tolua_variable(tolua_S,"FMin6",tolua_get_ItemSet_FMin6,tolua_set_ItemSet_FMin6);
   tolua_variable(tolua_S,"FMax6",tolua_get_ItemSet_FMax6,tolua_set_ItemSet_FMax6);
   tolua_variable(tolua_S,"FCode7",tolua_get_ItemSet_FCode7,tolua_set_ItemSet_FCode7);
   tolua_variable(tolua_S,"FParam7",tolua_get_ItemSet_FParam7,tolua_set_ItemSet_FParam7);
   tolua_variable(tolua_S,"FMin7",tolua_get_ItemSet_FMin7,tolua_set_ItemSet_FMin7);
   tolua_variable(tolua_S,"FMax7",tolua_get_ItemSet_FMax7,tolua_set_ItemSet_FMax7);
   tolua_variable(tolua_S,"FCode8",tolua_get_ItemSet_FCode8,tolua_set_ItemSet_FCode8);
   tolua_variable(tolua_S,"FParam8",tolua_get_ItemSet_FParam8,tolua_set_ItemSet_FParam8);
   tolua_variable(tolua_S,"FMin8",tolua_get_ItemSet_FMin8,tolua_set_ItemSet_FMin8);
   tolua_variable(tolua_S,"FMax8",tolua_get_ItemSet_FMax8,tolua_set_ItemSet_FMax8);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"BaseSetItem","BaseSetItem","",NULL);
  tolua_beginmodule(tolua_S,"BaseSetItem");
   tolua_variable(tolua_S,"Index",tolua_get_BaseSetItem_Index,tolua_set_BaseSetItem_Index);
   tolua_variable(tolua_S,"Id",tolua_get_BaseSetItem_Id,tolua_set_BaseSetItem_Id);
   tolua_variable(tolua_S,"Name",tolua_get_BaseSetItem_Name,tolua_set_BaseSetItem_Name);
   tolua_variable(tolua_S,"Set",tolua_get_BaseSetItem_Set_ptr,tolua_set_BaseSetItem_Set_ptr);
   tolua_variable(tolua_S,"Item",tolua_get_BaseSetItem_Item_ptr,tolua_set_BaseSetItem_Item_ptr);
   tolua_variable(tolua_S,"Rarity",tolua_get_BaseSetItem_Rarity,tolua_set_BaseSetItem_Rarity);
   tolua_variable(tolua_S,"DropLevel",tolua_get_BaseSetItem_DropLevel,tolua_set_BaseSetItem_DropLevel);
   tolua_variable(tolua_S,"RequiredLevel",tolua_get_BaseSetItem_RequiredLevel,tolua_set_BaseSetItem_RequiredLevel);
   tolua_variable(tolua_S,"CharTransform",tolua_get_BaseSetItem_CharTransform,tolua_set_BaseSetItem_CharTransform);
   tolua_variable(tolua_S,"InvTransform",tolua_get_BaseSetItem_InvTransform,tolua_set_BaseSetItem_InvTransform);
   tolua_variable(tolua_S,"InvFile",tolua_get_BaseSetItem_InvFile,tolua_set_BaseSetItem_InvFile);
   tolua_variable(tolua_S,"FlippyFile",tolua_get_BaseSetItem_FlippyFile,tolua_set_BaseSetItem_FlippyFile);
   tolua_variable(tolua_S,"DropSound",tolua_get_BaseSetItem_DropSound,tolua_set_BaseSetItem_DropSound);
   tolua_variable(tolua_S,"DropSfxFrame",tolua_get_BaseSetItem_DropSfxFrame,tolua_set_BaseSetItem_DropSfxFrame);
   tolua_variable(tolua_S,"UseSound",tolua_get_BaseSetItem_UseSound,tolua_set_BaseSetItem_UseSound);
   tolua_variable(tolua_S,"CostMultiply",tolua_get_BaseSetItem_CostMultiply,tolua_set_BaseSetItem_CostMultiply);
   tolua_variable(tolua_S,"CostAdd",tolua_get_BaseSetItem_CostAdd,tolua_set_BaseSetItem_CostAdd);
   tolua_variable(tolua_S,"AddFunc",tolua_get_BaseSetItem_AddFunc,tolua_set_BaseSetItem_AddFunc);
   tolua_variable(tolua_S,"Property1",tolua_get_BaseSetItem_Property1_ptr,tolua_set_BaseSetItem_Property1_ptr);
   tolua_variable(tolua_S,"Param1",tolua_get_BaseSetItem_Param1,tolua_set_BaseSetItem_Param1);
   tolua_variable(tolua_S,"Min1",tolua_get_BaseSetItem_Min1,tolua_set_BaseSetItem_Min1);
   tolua_variable(tolua_S,"Max1",tolua_get_BaseSetItem_Max1,tolua_set_BaseSetItem_Max1);
   tolua_variable(tolua_S,"Property2",tolua_get_BaseSetItem_Property2_ptr,tolua_set_BaseSetItem_Property2_ptr);
   tolua_variable(tolua_S,"Param2",tolua_get_BaseSetItem_Param2,tolua_set_BaseSetItem_Param2);
   tolua_variable(tolua_S,"Min2",tolua_get_BaseSetItem_Min2,tolua_set_BaseSetItem_Min2);
   tolua_variable(tolua_S,"Max2",tolua_get_BaseSetItem_Max2,tolua_set_BaseSetItem_Max2);
   tolua_variable(tolua_S,"Property3",tolua_get_BaseSetItem_Property3_ptr,tolua_set_BaseSetItem_Property3_ptr);
   tolua_variable(tolua_S,"Param3",tolua_get_BaseSetItem_Param3,tolua_set_BaseSetItem_Param3);
   tolua_variable(tolua_S,"Min3",tolua_get_BaseSetItem_Min3,tolua_set_BaseSetItem_Min3);
   tolua_variable(tolua_S,"Max3",tolua_get_BaseSetItem_Max3,tolua_set_BaseSetItem_Max3);
   tolua_variable(tolua_S,"Property4",tolua_get_BaseSetItem_Property4_ptr,tolua_set_BaseSetItem_Property4_ptr);
   tolua_variable(tolua_S,"Param4",tolua_get_BaseSetItem_Param4,tolua_set_BaseSetItem_Param4);
   tolua_variable(tolua_S,"Min4",tolua_get_BaseSetItem_Min4,tolua_set_BaseSetItem_Min4);
   tolua_variable(tolua_S,"Max4",tolua_get_BaseSetItem_Max4,tolua_set_BaseSetItem_Max4);
   tolua_variable(tolua_S,"Property5",tolua_get_BaseSetItem_Property5_ptr,tolua_set_BaseSetItem_Property5_ptr);
   tolua_variable(tolua_S,"Param5",tolua_get_BaseSetItem_Param5,tolua_set_BaseSetItem_Param5);
   tolua_variable(tolua_S,"Min5",tolua_get_BaseSetItem_Min5,tolua_set_BaseSetItem_Min5);
   tolua_variable(tolua_S,"Max5",tolua_get_BaseSetItem_Max5,tolua_set_BaseSetItem_Max5);
   tolua_variable(tolua_S,"Property6",tolua_get_BaseSetItem_Property6_ptr,tolua_set_BaseSetItem_Property6_ptr);
   tolua_variable(tolua_S,"Param6",tolua_get_BaseSetItem_Param6,tolua_set_BaseSetItem_Param6);
   tolua_variable(tolua_S,"Min6",tolua_get_BaseSetItem_Min6,tolua_set_BaseSetItem_Min6);
   tolua_variable(tolua_S,"Max6",tolua_get_BaseSetItem_Max6,tolua_set_BaseSetItem_Max6);
   tolua_variable(tolua_S,"Property7",tolua_get_BaseSetItem_Property7_ptr,tolua_set_BaseSetItem_Property7_ptr);
   tolua_variable(tolua_S,"Param7",tolua_get_BaseSetItem_Param7,tolua_set_BaseSetItem_Param7);
   tolua_variable(tolua_S,"Min7",tolua_get_BaseSetItem_Min7,tolua_set_BaseSetItem_Min7);
   tolua_variable(tolua_S,"Max7",tolua_get_BaseSetItem_Max7,tolua_set_BaseSetItem_Max7);
   tolua_variable(tolua_S,"Property8",tolua_get_BaseSetItem_Property8_ptr,tolua_set_BaseSetItem_Property8_ptr);
   tolua_variable(tolua_S,"Param8",tolua_get_BaseSetItem_Param8,tolua_set_BaseSetItem_Param8);
   tolua_variable(tolua_S,"Min8",tolua_get_BaseSetItem_Min8,tolua_set_BaseSetItem_Min8);
   tolua_variable(tolua_S,"Max8",tolua_get_BaseSetItem_Max8,tolua_set_BaseSetItem_Max8);
   tolua_variable(tolua_S,"Property9",tolua_get_BaseSetItem_Property9_ptr,tolua_set_BaseSetItem_Property9_ptr);
   tolua_variable(tolua_S,"Param9",tolua_get_BaseSetItem_Param9,tolua_set_BaseSetItem_Param9);
   tolua_variable(tolua_S,"Min9",tolua_get_BaseSetItem_Min9,tolua_set_BaseSetItem_Min9);
   tolua_variable(tolua_S,"Max9",tolua_get_BaseSetItem_Max9,tolua_set_BaseSetItem_Max9);
   tolua_variable(tolua_S,"AProperty1a",tolua_get_BaseSetItem_AProperty1a_ptr,tolua_set_BaseSetItem_AProperty1a_ptr);
   tolua_variable(tolua_S,"AParam1a",tolua_get_BaseSetItem_AParam1a,tolua_set_BaseSetItem_AParam1a);
   tolua_variable(tolua_S,"AMin1a",tolua_get_BaseSetItem_AMin1a,tolua_set_BaseSetItem_AMin1a);
   tolua_variable(tolua_S,"AMax1a",tolua_get_BaseSetItem_AMax1a,tolua_set_BaseSetItem_AMax1a);
   tolua_variable(tolua_S,"AProperty1b",tolua_get_BaseSetItem_AProperty1b_ptr,tolua_set_BaseSetItem_AProperty1b_ptr);
   tolua_variable(tolua_S,"AParam1b",tolua_get_BaseSetItem_AParam1b,tolua_set_BaseSetItem_AParam1b);
   tolua_variable(tolua_S,"AMin1b",tolua_get_BaseSetItem_AMin1b,tolua_set_BaseSetItem_AMin1b);
   tolua_variable(tolua_S,"AMax1b",tolua_get_BaseSetItem_AMax1b,tolua_set_BaseSetItem_AMax1b);
   tolua_variable(tolua_S,"AProperty2a",tolua_get_BaseSetItem_AProperty2a_ptr,tolua_set_BaseSetItem_AProperty2a_ptr);
   tolua_variable(tolua_S,"AParam2a",tolua_get_BaseSetItem_AParam2a,tolua_set_BaseSetItem_AParam2a);
   tolua_variable(tolua_S,"AMin2a",tolua_get_BaseSetItem_AMin2a,tolua_set_BaseSetItem_AMin2a);
   tolua_variable(tolua_S,"AMax2a",tolua_get_BaseSetItem_AMax2a,tolua_set_BaseSetItem_AMax2a);
   tolua_variable(tolua_S,"AProperty2b",tolua_get_BaseSetItem_AProperty2b_ptr,tolua_set_BaseSetItem_AProperty2b_ptr);
   tolua_variable(tolua_S,"AParam2b",tolua_get_BaseSetItem_AParam2b,tolua_set_BaseSetItem_AParam2b);
   tolua_variable(tolua_S,"AMin2b",tolua_get_BaseSetItem_AMin2b,tolua_set_BaseSetItem_AMin2b);
   tolua_variable(tolua_S,"AMax2b",tolua_get_BaseSetItem_AMax2b,tolua_set_BaseSetItem_AMax2b);
   tolua_variable(tolua_S,"AProperty3a",tolua_get_BaseSetItem_AProperty3a_ptr,tolua_set_BaseSetItem_AProperty3a_ptr);
   tolua_variable(tolua_S,"AParam3a",tolua_get_BaseSetItem_AParam3a,tolua_set_BaseSetItem_AParam3a);
   tolua_variable(tolua_S,"AMin3a",tolua_get_BaseSetItem_AMin3a,tolua_set_BaseSetItem_AMin3a);
   tolua_variable(tolua_S,"AMax3a",tolua_get_BaseSetItem_AMax3a,tolua_set_BaseSetItem_AMax3a);
   tolua_variable(tolua_S,"AProperty3b",tolua_get_BaseSetItem_AProperty3b_ptr,tolua_set_BaseSetItem_AProperty3b_ptr);
   tolua_variable(tolua_S,"AParam3b",tolua_get_BaseSetItem_AParam3b,tolua_set_BaseSetItem_AParam3b);
   tolua_variable(tolua_S,"AMin3b",tolua_get_BaseSetItem_AMin3b,tolua_set_BaseSetItem_AMin3b);
   tolua_variable(tolua_S,"AMax3b",tolua_get_BaseSetItem_AMax3b,tolua_set_BaseSetItem_AMax3b);
   tolua_variable(tolua_S,"AProperty4a",tolua_get_BaseSetItem_AProperty4a_ptr,tolua_set_BaseSetItem_AProperty4a_ptr);
   tolua_variable(tolua_S,"AParam4a",tolua_get_BaseSetItem_AParam4a,tolua_set_BaseSetItem_AParam4a);
   tolua_variable(tolua_S,"AMin4a",tolua_get_BaseSetItem_AMin4a,tolua_set_BaseSetItem_AMin4a);
   tolua_variable(tolua_S,"AMax4a",tolua_get_BaseSetItem_AMax4a,tolua_set_BaseSetItem_AMax4a);
   tolua_variable(tolua_S,"AProperty4b",tolua_get_BaseSetItem_AProperty4b_ptr,tolua_set_BaseSetItem_AProperty4b_ptr);
   tolua_variable(tolua_S,"AParam4b",tolua_get_BaseSetItem_AParam4b,tolua_set_BaseSetItem_AParam4b);
   tolua_variable(tolua_S,"AMin4b",tolua_get_BaseSetItem_AMin4b,tolua_set_BaseSetItem_AMin4b);
   tolua_variable(tolua_S,"AMax4b",tolua_get_BaseSetItem_AMax4b,tolua_set_BaseSetItem_AMax4b);
   tolua_variable(tolua_S,"AProperty5a",tolua_get_BaseSetItem_AProperty5a_ptr,tolua_set_BaseSetItem_AProperty5a_ptr);
   tolua_variable(tolua_S,"AParam5a",tolua_get_BaseSetItem_AParam5a,tolua_set_BaseSetItem_AParam5a);
   tolua_variable(tolua_S,"AMin5a",tolua_get_BaseSetItem_AMin5a,tolua_set_BaseSetItem_AMin5a);
   tolua_variable(tolua_S,"AMax5a",tolua_get_BaseSetItem_AMax5a,tolua_set_BaseSetItem_AMax5a);
   tolua_variable(tolua_S,"AProperty5b",tolua_get_BaseSetItem_AProperty5b_ptr,tolua_set_BaseSetItem_AProperty5b_ptr);
   tolua_variable(tolua_S,"AParam5b",tolua_get_BaseSetItem_AParam5b,tolua_set_BaseSetItem_AParam5b);
   tolua_variable(tolua_S,"AMin5b",tolua_get_BaseSetItem_AMin5b,tolua_set_BaseSetItem_AMin5b);
   tolua_variable(tolua_S,"AMax5b",tolua_get_BaseSetItem_AMax5b,tolua_set_BaseSetItem_AMax5b);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"std",0);
  tolua_beginmodule(tolua_S,"std");
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_MagicPrefixType__MagicPrefixType_","std::vector<MagicPrefixType::MagicPrefixType>","",tolua_collect_std__vector_MagicPrefixType__MagicPrefixType_);
   #else
   tolua_cclass(tolua_S,"vector_MagicPrefixType__MagicPrefixType_","std::vector<MagicPrefixType::MagicPrefixType>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_MagicPrefixType__MagicPrefixType_");
    tolua_function(tolua_S,"clear",tolua_item_std_vector_MagicPrefixType__MagicPrefixType__clear00);
    tolua_function(tolua_S,"size",tolua_item_std_vector_MagicPrefixType__MagicPrefixType__size00);
    tolua_function(tolua_S,".geti",tolua_item_std_vector_MagicPrefixType__MagicPrefixType___geti00);
    tolua_function(tolua_S,".seti",tolua_item_std_vector_MagicPrefixType__MagicPrefixType___seti00);
    tolua_function(tolua_S,".geti",tolua_item_std_vector_MagicPrefixType__MagicPrefixType___geti01);
    tolua_function(tolua_S,"push_back",tolua_item_std_vector_MagicPrefixType__MagicPrefixType__push_back00);
    tolua_function(tolua_S,"new",tolua_item_std_vector_MagicPrefixType__MagicPrefixType__new00);
    tolua_function(tolua_S,"new_local",tolua_item_std_vector_MagicPrefixType__MagicPrefixType__new00_local);
    tolua_function(tolua_S,".call",tolua_item_std_vector_MagicPrefixType__MagicPrefixType__new00_local);
    tolua_function(tolua_S,"delete",tolua_item_std_vector_MagicPrefixType__MagicPrefixType__delete00);
   tolua_endmodule(tolua_S);
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"vector_StatBase_","std::vector<StatBase>","",tolua_collect_std__vector_StatBase_);
   #else
   tolua_cclass(tolua_S,"vector_StatBase_","std::vector<StatBase>","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"vector_StatBase_");
    tolua_function(tolua_S,"clear",tolua_item_std_vector_StatBase__clear00);
    tolua_function(tolua_S,"size",tolua_item_std_vector_StatBase__size00);
    tolua_function(tolua_S,".geti",tolua_item_std_vector_StatBase___geti00);
    tolua_function(tolua_S,".seti",tolua_item_std_vector_StatBase___seti00);
    tolua_function(tolua_S,".geti",tolua_item_std_vector_StatBase___geti01);
    tolua_function(tolua_S,"push_back",tolua_item_std_vector_StatBase__push_back00);
    tolua_function(tolua_S,"new",tolua_item_std_vector_StatBase__new00);
    tolua_function(tolua_S,"new_local",tolua_item_std_vector_StatBase__new00_local);
    tolua_function(tolua_S,".call",tolua_item_std_vector_StatBase__new00_local);
    tolua_function(tolua_S,"delete",tolua_item_std_vector_StatBase__delete00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Item","Item","",tolua_collect_Item);
  #else
  tolua_cclass(tolua_S,"Item","Item","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"Item");
   tolua_variable(tolua_S,"action",tolua_get_Item_action,tolua_set_Item_action);
   tolua_variable(tolua_S,"category",tolua_get_Item_category,tolua_set_Item_category);
   tolua_variable(tolua_S,"uid",tolua_get_Item_unsigned_uid,tolua_set_Item_unsigned_uid);
   tolua_variable(tolua_S,"flags",tolua_get_Item_flags,tolua_set_Item_flags);
   tolua_variable(tolua_S,"version",tolua_get_Item_version,tolua_set_Item_version);
   tolua_variable(tolua_S,"destination",tolua_get_Item_destination,tolua_set_Item_destination);
   tolua_variable(tolua_S,"location",tolua_get_Item_location,tolua_set_Item_location);
   tolua_variable(tolua_S,"x",tolua_get_Item_x,tolua_set_Item_x);
   tolua_variable(tolua_S,"y",tolua_get_Item_y,tolua_set_Item_y);
   tolua_variable(tolua_S,"container",tolua_get_Item_container,tolua_set_Item_container);
   tolua_variable(tolua_S,"baseItem",tolua_get_Item_baseItem_ptr,tolua_set_Item_baseItem_ptr);
   tolua_variable(tolua_S,"setItem",tolua_get_Item_setItem_ptr,tolua_set_Item_setItem_ptr);
   tolua_variable(tolua_S,"uniqueItem",tolua_get_Item_uniqueItem_ptr,tolua_set_Item_uniqueItem_ptr);
   tolua_variable(tolua_S,"runeword",tolua_get_Item_runeword_ptr,tolua_set_Item_runeword_ptr);
   tolua_variable(tolua_S,"quality",tolua_get_Item_quality,tolua_set_Item_quality);
   tolua_variable(tolua_S,"superiorType",tolua_get_Item_superiorType,tolua_set_Item_superiorType);
   tolua_variable(tolua_S,"prefix",tolua_get_Item_prefix,tolua_set_Item_prefix);
   tolua_variable(tolua_S,"suffix",tolua_get_Item_suffix,tolua_set_Item_suffix);
   tolua_variable(tolua_S,"magicPrefixes",tolua_get_Item_magicPrefixes,tolua_set_Item_magicPrefixes);
   tolua_variable(tolua_S,"magicSuffixes",tolua_get_Item_magicSuffixes,tolua_set_Item_magicSuffixes);
   tolua_variable(tolua_S,"name",tolua_get_Item_name,tolua_set_Item_name);
   tolua_variable(tolua_S,"charClass",tolua_get_Item_charClass,tolua_set_Item_charClass);
   tolua_variable(tolua_S,"level",tolua_get_Item_level,tolua_set_Item_level);
   tolua_variable(tolua_S,"usedSockets",tolua_get_Item_usedSockets,tolua_set_Item_usedSockets);
   tolua_variable(tolua_S,"use",tolua_get_Item_use,tolua_set_Item_use);
   tolua_variable(tolua_S,"graphic",tolua_get_Item_graphic,tolua_set_Item_graphic);
   tolua_variable(tolua_S,"color",tolua_get_Item_color,tolua_set_Item_color);
   tolua_variable(tolua_S,"stats",tolua_get_Item_stats,tolua_set_Item_stats);
   tolua_variable(tolua_S,"mods",tolua_get_Item_mods,tolua_set_Item_mods);
   tolua_variable(tolua_S,"unknown1",tolua_get_Item_unknown1,tolua_set_Item_unknown1);
   tolua_variable(tolua_S,"runewordID",tolua_get_Item_runewordID,tolua_set_Item_runewordID);
   tolua_variable(tolua_S,"runewordParam",tolua_get_Item_runewordParam,tolua_set_Item_runewordParam);
   tolua_function(tolua_S,"new",tolua_item_Item_new00);
   tolua_function(tolua_S,"new_local",tolua_item_Item_new00_local);
   tolua_function(tolua_S,".call",tolua_item_Item_new00_local);
   tolua_function(tolua_S,"delete",tolua_item_Item_delete00);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_item (lua_State* tolua_S) {
 return tolua_item_open(tolua_S);
};
#endif