#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    public class UIHelperWrap 
    {
        public static void __Register(RealStatePtr L)
        {
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			System.Type type = typeof(UIHelper);
			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
			
			
			
			
			
			
			Utils.EndObjectRegister(type, L, translator, null, null,
			    null, null, null);

		    Utils.BeginClassRegister(type, L, __CreateInstance, 65, 0, 0);
			Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSuitNameByName", _m_GetSuitNameByName_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSurplusSeconds", _m_GetSurplusSeconds_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTime", _m_GetTime_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetFadeTime", _m_GetFadeTime_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetPropertyValue", _m_GetPropertyValue_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ReplaceNewLine", _m_ReplaceNewLine_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ReplaceLargeNum", _m_ReplaceLargeNum_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ReplaceXianYuanCoinsNum", _m_ReplaceXianYuanCoinsNum_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ReplacePercentage", _m_ReplacePercentage_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetPropertyDecimalCount", _m_GetPropertyDecimalCount_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "HasSpecialCharac", _m_HasSpecialCharac_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetColorNameByItemColor", _m_GetColorNameByItemColor_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetDanLVColor", _m_GetDanLVColor_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AppendDanLVNameColor", _m_AppendDanLVNameColor_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetUIColor", _m_GetUIColor_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AppendColor", _m_AppendColor_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetRealmName", _m_GetRealmName_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetRealmColorByLv", _m_GetRealmColorByLv_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetItemColor", _m_GetItemColor_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetFightPower", _m_GetFightPower_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetFightPowerParmByAttrId", _m_GetFightPowerParmByAttrId_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMoneyCnt", _m_GetMoneyCnt_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetEquipPlaceName", _m_GetEquipPlaceName_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ServerStringTrim", _m_ServerStringTrim_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetIntervalAward", _m_GetIntervalAward_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetGrade", _m_GetGrade_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "TrimContentToServer", _m_TrimContentToServer_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SatisfyNameLength", _m_SatisfyNameLength_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetChsCount", _m_GetChsCount_xlua_st_);
            
			
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_BrightPinkColor", UIHelper.s_BrightPinkColor);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_BrightRedColor", UIHelper.s_BrightRedColor);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_BrightPurpleColor", UIHelper.s_BrightPurpleColor);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_BrightBlueColor", UIHelper.s_BrightBlueColor);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_BrightOrangeColor", UIHelper.s_BrightOrangeColor);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_BrightWhiteColor", UIHelper.s_BrightWhiteColor);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_BrightGreenColor", UIHelper.s_BrightGreenColor);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_DarkPinkColor", UIHelper.s_DarkPinkColor);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_DarkRedColor", UIHelper.s_DarkRedColor);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_DarkPurpleColor", UIHelper.s_DarkPurpleColor);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_DarkBlueColor", UIHelper.s_DarkBlueColor);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_DarkOrangeColor", UIHelper.s_DarkOrangeColor);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_DarkWhiteColor", UIHelper.s_DarkWhiteColor);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_DarkGreenColor", UIHelper.s_DarkGreenColor);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_NavyBrown", UIHelper.s_NavyBrown);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_Black", UIHelper.s_Black);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_NavyYellow", UIHelper.s_NavyYellow);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_LightGreen", UIHelper.s_LightGreen);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_LightYellow", UIHelper.s_LightYellow);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_Gray", UIHelper.s_Gray);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_BrightDanLV0", UIHelper.s_BrightDanLV0);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_BrightDanLV1", UIHelper.s_BrightDanLV1);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_BrightDanLV2", UIHelper.s_BrightDanLV2);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_BrightDanLV3", UIHelper.s_BrightDanLV3);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_BrightDanLV4", UIHelper.s_BrightDanLV4);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_BrightDanLV5", UIHelper.s_BrightDanLV5);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_BrightDanLV6", UIHelper.s_BrightDanLV6);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_GrayDanLV0", UIHelper.s_GrayDanLV0);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_GrayDanLV1", UIHelper.s_GrayDanLV1);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_GrayDanLV2", UIHelper.s_GrayDanLV2);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_GrayDanLV3", UIHelper.s_GrayDanLV3);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_GrayDanLV4", UIHelper.s_GrayDanLV4);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_GrayDanLV5", UIHelper.s_GrayDanLV5);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "s_GrayDanLV6", UIHelper.s_GrayDanLV6);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightPowerFormula", UIHelper.FightPowerFormula);
            
			
			
			
			Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            return LuaAPI.luaL_error(L, "UIHelper does not have a constructor!");
        }
        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetSuitNameByName_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _attrName = LuaAPI.lua_tostring(L, 1);
                    
                        string gen_ret = UIHelper.GetSuitNameByName( _attrName );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetSurplusSeconds_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _startTime = LuaAPI.lua_tostring(L, 1);
                    int _seconds = LuaAPI.xlua_tointeger(L, 2);
                    
                        int gen_ret = UIHelper.GetSurplusSeconds( _startTime, _seconds );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTime_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _startTime = LuaAPI.lua_tostring(L, 1);
                    
                        string gen_ret = UIHelper.GetTime( _startTime );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetFadeTime_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    uint _lastTime = LuaAPI.xlua_touint(L, 1);
                    
                        string gen_ret = UIHelper.GetFadeTime( _lastTime );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetPropertyValue_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    PropertyType _type;translator.Get(L, 1, out _type);
                    
                        int gen_ret = UIHelper.GetPropertyValue( _type );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ReplaceNewLine_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _val = LuaAPI.lua_tostring(L, 1);
                    
                        string gen_ret = UIHelper.ReplaceNewLine( _val );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ReplaceLargeNum_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    double _num = LuaAPI.lua_tonumber(L, 1);
                    
                        string gen_ret = UIHelper.ReplaceLargeNum( _num );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ReplaceXianYuanCoinsNum_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    double _num = LuaAPI.lua_tonumber(L, 1);
                    
                        string gen_ret = UIHelper.ReplaceXianYuanCoinsNum( _num );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ReplacePercentage_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) 
                {
                    float _num = (float)LuaAPI.lua_tonumber(L, 1);
                    int _isPer = LuaAPI.xlua_tointeger(L, 2);
                    int _decimals = LuaAPI.xlua_tointeger(L, 3);
                    
                        float gen_ret = UIHelper.ReplacePercentage( _num, _isPer, _decimals );
                        LuaAPI.lua_pushnumber(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
                {
                    float _num = (float)LuaAPI.lua_tonumber(L, 1);
                    int _isPer = LuaAPI.xlua_tointeger(L, 2);
                    
                        float gen_ret = UIHelper.ReplacePercentage( _num, _isPer );
                        LuaAPI.lua_pushnumber(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to UIHelper.ReplacePercentage!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetPropertyDecimalCount_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _property = LuaAPI.xlua_tointeger(L, 1);
                    
                        int gen_ret = UIHelper.GetPropertyDecimalCount( _property );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HasSpecialCharac_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _str = LuaAPI.lua_tostring(L, 1);
                    
                        bool gen_ret = UIHelper.HasSpecialCharac( _str );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetColorNameByItemColor_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _itemColor = LuaAPI.xlua_tointeger(L, 1);
                    
                        string gen_ret = UIHelper.GetColorNameByItemColor( _itemColor );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetDanLVColor_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) 
                {
                    int _danLv = LuaAPI.xlua_tointeger(L, 1);
                    bool _bright = LuaAPI.lua_toboolean(L, 2);
                    
                        UnityEngine.Color gen_ret = UIHelper.GetDanLVColor( _danLv, _bright );
                        translator.PushUnityEngineColor(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int _danLv = LuaAPI.xlua_tointeger(L, 1);
                    
                        UnityEngine.Color gen_ret = UIHelper.GetDanLVColor( _danLv );
                        translator.PushUnityEngineColor(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to UIHelper.GetDanLVColor!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AppendDanLVNameColor_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) 
                {
                    int _danLv = LuaAPI.xlua_tointeger(L, 1);
                    bool _bright = LuaAPI.lua_toboolean(L, 2);
                    
                        string gen_ret = UIHelper.AppendDanLVNameColor( _danLv, _bright );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int _danLv = LuaAPI.xlua_tointeger(L, 1);
                    
                        string gen_ret = UIHelper.AppendDanLVNameColor( _danLv );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to UIHelper.AppendDanLVNameColor!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetUIColor_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) 
                {
                    int _itemColor = LuaAPI.xlua_tointeger(L, 1);
                    bool _bright = LuaAPI.lua_toboolean(L, 2);
                    
                        UnityEngine.Color gen_ret = UIHelper.GetUIColor( _itemColor, _bright );
                        translator.PushUnityEngineColor(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int _itemColor = LuaAPI.xlua_tointeger(L, 1);
                    
                        UnityEngine.Color gen_ret = UIHelper.GetUIColor( _itemColor );
                        translator.PushUnityEngineColor(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 2&& translator.Assignable<TextColType>(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) 
                {
                    TextColType _type;translator.Get(L, 1, out _type);
                    bool _bright = LuaAPI.lua_toboolean(L, 2);
                    
                        UnityEngine.Color gen_ret = UIHelper.GetUIColor( _type, _bright );
                        translator.PushUnityEngineColor(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 1&& translator.Assignable<TextColType>(L, 1)) 
                {
                    TextColType _type;translator.Get(L, 1, out _type);
                    
                        UnityEngine.Color gen_ret = UIHelper.GetUIColor( _type );
                        translator.PushUnityEngineColor(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to UIHelper.GetUIColor!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AppendColor_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) 
                {
                    int _itemColor = LuaAPI.xlua_tointeger(L, 1);
                    string _msg = LuaAPI.lua_tostring(L, 2);
                    bool _bright = LuaAPI.lua_toboolean(L, 3);
                    
                        string gen_ret = UIHelper.AppendColor( _itemColor, _msg, _bright );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) 
                {
                    int _itemColor = LuaAPI.xlua_tointeger(L, 1);
                    string _msg = LuaAPI.lua_tostring(L, 2);
                    
                        string gen_ret = UIHelper.AppendColor( _itemColor, _msg );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 3&& translator.Assignable<TextColType>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) 
                {
                    TextColType _type;translator.Get(L, 1, out _type);
                    string _msg = LuaAPI.lua_tostring(L, 2);
                    bool _bright = LuaAPI.lua_toboolean(L, 3);
                    
                        string gen_ret = UIHelper.AppendColor( _type, _msg, _bright );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 2&& translator.Assignable<TextColType>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) 
                {
                    TextColType _type;translator.Get(L, 1, out _type);
                    string _msg = LuaAPI.lua_tostring(L, 2);
                    
                        string gen_ret = UIHelper.AppendColor( _type, _msg );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to UIHelper.AppendColor!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetRealmName_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) 
                {
                    int _realmLv = LuaAPI.xlua_tointeger(L, 1);
                    bool _bright = LuaAPI.lua_toboolean(L, 2);
                    
                        string gen_ret = UIHelper.GetRealmName( _realmLv, _bright );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int _realmLv = LuaAPI.xlua_tointeger(L, 1);
                    
                        string gen_ret = UIHelper.GetRealmName( _realmLv );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to UIHelper.GetRealmName!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetRealmColorByLv_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) 
                {
                    int _realmLv = LuaAPI.xlua_tointeger(L, 1);
                    string _msg = LuaAPI.lua_tostring(L, 2);
                    bool _bright = LuaAPI.lua_toboolean(L, 3);
                    
                        string gen_ret = UIHelper.GetRealmColorByLv( _realmLv, _msg, _bright );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) 
                {
                    int _realmLv = LuaAPI.xlua_tointeger(L, 1);
                    string _msg = LuaAPI.lua_tostring(L, 2);
                    
                        string gen_ret = UIHelper.GetRealmColorByLv( _realmLv, _msg );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to UIHelper.GetRealmColorByLv!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetItemColor_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable<System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<int>>>(L, 2)) 
                {
                    int __id = LuaAPI.xlua_tointeger(L, 1);
                    System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<int>> __dict = (System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<int>>)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<int>>));
                    
                        int gen_ret = UIHelper.GetItemColor( __id, __dict );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int __id = LuaAPI.xlua_tointeger(L, 1);
                    
                        int gen_ret = UIHelper.GetItemColor( __id );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to UIHelper.GetItemColor!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetFightPower_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Collections.Generic.Dictionary<int, int> __propertyDict = (System.Collections.Generic.Dictionary<int, int>)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary<int, int>));
                    
                        int gen_ret = UIHelper.GetFightPower( __propertyDict );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetFightPowerParmByAttrId_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _attrId = LuaAPI.xlua_tointeger(L, 1);
                    
                        int gen_ret = UIHelper.GetFightPowerParmByAttrId( _attrId );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMoneyCnt_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _moneyType = LuaAPI.xlua_tointeger(L, 1);
                    
                        ulong gen_ret = UIHelper.GetMoneyCnt( _moneyType );
                        LuaAPI.lua_pushuint64(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetEquipPlaceName_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _place = LuaAPI.xlua_tointeger(L, 1);
                    
                        string gen_ret = UIHelper.GetEquipPlaceName( _place );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ServerStringTrim_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _str = LuaAPI.lua_tostring(L, 1);
                    
                        string gen_ret = UIHelper.ServerStringTrim( _str );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetIntervalAward_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Collections.Generic.ICollection<int> __keys = (System.Collections.Generic.ICollection<int>)translator.GetObject(L, 1, typeof(System.Collections.Generic.ICollection<int>));
                    int __present = LuaAPI.xlua_tointeger(L, 2);
                    
                        int gen_ret = UIHelper.GetIntervalAward( __keys, __present );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetGrade_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int __star = LuaAPI.xlua_tointeger(L, 1);
                    
                        string gen_ret = UIHelper.GetGrade( __star );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TrimContentToServer_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _content = LuaAPI.lua_tostring(L, 1);
                    
                        string gen_ret = UIHelper.TrimContentToServer( _content );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SatisfyNameLength_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _name = LuaAPI.lua_tostring(L, 1);
                    int _error;
                    
                        bool gen_ret = UIHelper.SatisfyNameLength( _name, out _error );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    LuaAPI.xlua_pushinteger(L, _error);
                        
                    
                    
                    
                    return 2;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetChsCount_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _name = LuaAPI.lua_tostring(L, 1);
                    
                        int gen_ret = UIHelper.GetChsCount( _name );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        
        
        
        
        
		
		
		
		
    }
}