Merge branch 'master' of http://192.168.0.87:10010/r/snxxz_scripts

client_linchunjie

2019-07-03 5bc5a28816aac81064189ae6f18a7e0739d81de5

Merge branch 'master' of http://192.168.0.87:10010/r/snxxz_scripts

 Core/NetworkPackage/DTCFile/ServerPack/HAD_SaleActivity.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: 3e05761d690b75440a6be79207d0fb01
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/DTCFile/ServerPack/HAE_Truck.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: 1d70ccd06161e0443b7a802ad94292f8
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/DTCFile/ServerPack/HAF_Merge.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: 71e878ac60c49ad4f964dd2dbc725739
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/DTCFile/ServerPack/HB0_Event.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: eed34091b0568664b9fb42f0634496c1
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/ServerPack/HAD_SaleActivity.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: 32ceb8b7faf99f84a8b73ce53c5e3e4d
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/ServerPack/HAE_Truck.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: 77f69c2b862d1704299a32d0d8eeb71e
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/ServerPack/HAF_Merge.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: fa14960fa44b0d1439bab471a764e34f
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/ServerPack/HB0_Event.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: d914565b65f8e8145988734c4d915834
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Lua/Gen/DelegatesGensBridge.cs

@@ -6279,97 +6279,7 @@
#endif
        }
        
        public Snxxz.UI.MagicianModel __Gen_Delegate_Imp272()
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
            {
#endif
                RealStatePtr L = luaEnv.rawL;
                int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference);
                ObjectTranslator translator = luaEnv.translator;
                
                PCall(L, 0, 1, errFunc);
                
                
                Snxxz.UI.MagicianModel __gen_ret = (Snxxz.UI.MagicianModel)translator.GetObject(L, errFunc + 1, typeof(Snxxz.UI.MagicianModel));
                LuaAPI.lua_settop(L, errFunc - 1);
                return  __gen_ret;
#if THREAD_SAFE || HOTFIX_ENABLE
            }
#endif
        }
        
        public bool __Gen_Delegate_Imp273(uint p0, out System.Collections.Generic.Dictionary<int, int> p1)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
            {
#endif
                RealStatePtr L = luaEnv.rawL;
                int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference);
                ObjectTranslator translator = luaEnv.translator;
                LuaAPI.xlua_pushuint(L, p0);
                
                PCall(L, 1, 2, errFunc);
                
                p1 = (System.Collections.Generic.Dictionary<int, int>)translator.GetObject(L, errFunc + 2, typeof(System.Collections.Generic.Dictionary<int, int>));
                
                bool __gen_ret = LuaAPI.lua_toboolean(L, errFunc + 1);
                LuaAPI.lua_settop(L, errFunc - 1);
                return  __gen_ret;
#if THREAD_SAFE || HOTFIX_ENABLE
            }
#endif
        }
        
        public bool __Gen_Delegate_Imp274(uint p0, int p1, out int p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
            {
#endif
                RealStatePtr L = luaEnv.rawL;
                int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference);
                
                LuaAPI.xlua_pushuint(L, p0);
                LuaAPI.xlua_pushinteger(L, p1);
                
                PCall(L, 2, 2, errFunc);
                
                p2 = LuaAPI.xlua_tointeger(L, errFunc + 2);
                
                bool __gen_ret = LuaAPI.lua_toboolean(L, errFunc + 1);
                LuaAPI.lua_settop(L, errFunc - 1);
                return  __gen_ret;
#if THREAD_SAFE || HOTFIX_ENABLE
            }
#endif
        }
        
        public void __Gen_Delegate_Imp276(uint p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
            {
#endif
                RealStatePtr L = luaEnv.rawL;
                int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference);
                
                LuaAPI.xlua_pushuint(L, p0);
                
                PCall(L, 1, 0, errFunc);
                
                
                
                LuaAPI.lua_settop(L, errFunc - 1);
                
#if THREAD_SAFE || HOTFIX_ENABLE
            }
#endif
        }
        
        public System.Collections.Generic.Dictionary<int, string> __Gen_Delegate_Imp277(object p0)
        public System.Collections.Generic.Dictionary<int, string> __Gen_Delegate_Imp272(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6391,7 +6301,7 @@
#endif
        }
        
        public int[] __Gen_Delegate_Imp278(object p0)
        public int[] __Gen_Delegate_Imp273(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6413,7 +6323,7 @@
#endif
        }
        
        public int[] __Gen_Delegate_Imp279(object p0, int p1)
        public int[] __Gen_Delegate_Imp274(object p0, int p1)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6436,7 +6346,7 @@
#endif
        }
        
        public Snxxz.UI.GodWeaponInfo __Gen_Delegate_Imp280(object p0, int p1)
        public Snxxz.UI.GodWeaponInfo __Gen_Delegate_Imp275(object p0, int p1)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6459,7 +6369,7 @@
#endif
        }
        
        public bool __Gen_Delegate_Imp281(object p0, int p1, out System.Collections.Generic.List<Snxxz.UI.GodWeaponCondition> p2)
        public bool __Gen_Delegate_Imp276(object p0, int p1, out System.Collections.Generic.List<Snxxz.UI.GodWeaponCondition> p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6483,7 +6393,7 @@
#endif
        }
        
        public bool __Gen_Delegate_Imp282(object p0, int p1, out Snxxz.UI.AutoHammerCost p2)
        public bool __Gen_Delegate_Imp277(object p0, int p1, out Snxxz.UI.AutoHammerCost p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6507,7 +6417,7 @@
#endif
        }
        
        public System.Collections.Generic.List<int> __Gen_Delegate_Imp283(object p0, int p1)
        public System.Collections.Generic.List<int> __Gen_Delegate_Imp278(object p0, int p1)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6530,7 +6440,7 @@
#endif
        }
        
        public void __Gen_Delegate_Imp284(object p0, object p1, object p2)
        public void __Gen_Delegate_Imp279(object p0, object p1, object p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6554,7 +6464,7 @@
#endif
        }
        
        public bool __Gen_Delegate_Imp285(object p0, int p1, out int p2, out int p3)
        public bool __Gen_Delegate_Imp280(object p0, int p1, out int p2, out int p3)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6579,7 +6489,7 @@
#endif
        }
        
        public string __Gen_Delegate_Imp286(object p0, int p1, int p2)
        public string __Gen_Delegate_Imp281(object p0, int p1, int p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6603,7 +6513,7 @@
#endif
        }
        
        public void __Gen_Delegate_Imp287(object p0, TextColType p1, bool p2)
        public void __Gen_Delegate_Imp282(object p0, TextColType p1, bool p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6627,7 +6537,7 @@
#endif
        }
        
        public uint __Gen_Delegate_Imp288(object p0)
        public uint __Gen_Delegate_Imp283(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6649,7 +6559,7 @@
#endif
        }
        
        public void __Gen_Delegate_Imp289(object p0, uint p1)
        public void __Gen_Delegate_Imp284(object p0, uint p1)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6672,7 +6582,7 @@
#endif
        }
        
        public bool __Gen_Delegate_Imp290(object p0, int p1, out Snxxz.UI.RuneItem p2)
        public bool __Gen_Delegate_Imp285(object p0, int p1, out Snxxz.UI.RuneItem p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6696,7 +6606,7 @@
#endif
        }
        
        public bool __Gen_Delegate_Imp291(object p0, int p1, out Snxxz.UI.RuneHoleCondition p2)
        public bool __Gen_Delegate_Imp286(object p0, int p1, out Snxxz.UI.RuneHoleCondition p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6720,7 +6630,7 @@
#endif
        }
        
        public int __Gen_Delegate_Imp292(object p0, int p1, out Snxxz.UI.RuneItem p2)
        public int __Gen_Delegate_Imp287(object p0, int p1, out Snxxz.UI.RuneItem p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6744,7 +6654,7 @@
#endif
        }
        
        public bool __Gen_Delegate_Imp293(object p0, int p1, out Snxxz.UI.RuneModel.RuneHoleRedpoint p2)
        public bool __Gen_Delegate_Imp288(object p0, int p1, out Snxxz.UI.RuneModel.RuneHoleRedpoint p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6768,7 +6678,7 @@
#endif
        }
        
        public int __Gen_Delegate_Imp294(object p0, int p1, float p2)
        public int __Gen_Delegate_Imp289(object p0, int p1, float p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6792,7 +6702,7 @@
#endif
        }
        
        public bool __Gen_Delegate_Imp295(object p0, int p1, uint p2)
        public bool __Gen_Delegate_Imp290(object p0, int p1, uint p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6816,7 +6726,7 @@
#endif
        }
        
        public Snxxz.UI.RuneResolveModel __Gen_Delegate_Imp296(object p0)
        public Snxxz.UI.RuneResolveModel __Gen_Delegate_Imp291(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6838,7 +6748,7 @@
#endif
        }
        
        public Snxxz.UI.RuneModel __Gen_Delegate_Imp297(object p0)
        public Snxxz.UI.RuneModel __Gen_Delegate_Imp292(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6860,7 +6770,7 @@
#endif
        }
        
        public float __Gen_Delegate_Imp298(object p0, int p1, int p2, bool p3)
        public float __Gen_Delegate_Imp293(object p0, int p1, int p2, bool p3)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6885,7 +6795,7 @@
#endif
        }
        
        public float __Gen_Delegate_Imp299(object p0, int p1)
        public float __Gen_Delegate_Imp294(object p0, int p1)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6908,7 +6818,7 @@
#endif
        }
        
        public bool __Gen_Delegate_Imp300(object p0, int p1, out Snxxz.UI.TreasureSkill p2)
        public bool __Gen_Delegate_Imp295(object p0, int p1, out Snxxz.UI.TreasureSkill p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6932,7 +6842,7 @@
#endif
        }
        
        public bool __Gen_Delegate_Imp301(object p0, int p1, out Snxxz.UI.TreasurePotential p2)
        public bool __Gen_Delegate_Imp296(object p0, int p1, out Snxxz.UI.TreasurePotential p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6956,7 +6866,7 @@
#endif
        }
        
        public Snxxz.UI.TreasureSkillModel __Gen_Delegate_Imp302(object p0)
        public Snxxz.UI.TreasureSkillModel __Gen_Delegate_Imp297(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6978,7 +6888,7 @@
#endif
        }
        
        public Snxxz.UI.SkillModel __Gen_Delegate_Imp303(object p0)
        public Snxxz.UI.SkillModel __Gen_Delegate_Imp298(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7000,7 +6910,7 @@
#endif
        }
        
        public Snxxz.UI.FuncSwitchModel __Gen_Delegate_Imp304(object p0)
        public Snxxz.UI.FuncSwitchModel __Gen_Delegate_Imp299(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7022,7 +6932,7 @@
#endif
        }
        
        public System.Collections.Generic.Dictionary<int, Snxxz.UI.FuncSwitchModel.FuncSwithData> __Gen_Delegate_Imp305(object p0)
        public System.Collections.Generic.Dictionary<int, Snxxz.UI.FuncSwitchModel.FuncSwithData> __Gen_Delegate_Imp300(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7044,7 +6954,7 @@
#endif
        }
        
        public Snxxz.UI.TestModel __Gen_Delegate_Imp306(object p0)
        public Snxxz.UI.TestModel __Gen_Delegate_Imp301(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7066,7 +6976,7 @@
#endif
        }
        
        public UIEffect __Gen_Delegate_Imp307(object p0)
        public UIEffect __Gen_Delegate_Imp302(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7088,7 +6998,7 @@
#endif
        }
        
        public Treasure3DConfig __Gen_Delegate_Imp308(object p0)
        public Treasure3DConfig __Gen_Delegate_Imp303(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7110,7 +7020,7 @@
#endif
        }
        
        public UnityEngine.Vector3 __Gen_Delegate_Imp309(object p0, UnityEngine.Vector3 p1)
        public UnityEngine.Vector3 __Gen_Delegate_Imp304(object p0, UnityEngine.Vector3 p1)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7133,7 +7043,7 @@
#endif
        }
        
        public UnityEngine.Vector3 __Gen_Delegate_Imp310(object p0)
        public UnityEngine.Vector3 __Gen_Delegate_Imp305(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7155,7 +7065,7 @@
#endif
        }
        
        public Treasure3DConfig.TreasureParam __Gen_Delegate_Imp311(object p0)
        public Treasure3DConfig.TreasureParam __Gen_Delegate_Imp306(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7177,7 +7087,7 @@
#endif
        }
        
        public Snxxz.UI.UI3DTreasureSelectStage __Gen_Delegate_Imp312()
        public Snxxz.UI.UI3DTreasureSelectStage __Gen_Delegate_Imp307()
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7198,7 +7108,7 @@
#endif
        }
        
        public TreasureCategory __Gen_Delegate_Imp313(object p0)
        public TreasureCategory __Gen_Delegate_Imp308(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7220,7 +7130,7 @@
#endif
        }
        
        public void __Gen_Delegate_Imp314(object p0, bool p1, TreasureCategory p2)
        public void __Gen_Delegate_Imp309(object p0, bool p1, TreasureCategory p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7244,7 +7154,7 @@
#endif
        }
        
        public System.Collections.IEnumerator __Gen_Delegate_Imp315(object p0, TreasureCategory p1, object p2)
        public System.Collections.IEnumerator __Gen_Delegate_Imp310(object p0, TreasureCategory p1, object p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7268,7 +7178,7 @@
#endif
        }
        
        public void __Gen_Delegate_Imp316(object p0, TreasureCategory p1, bool p2)
        public void __Gen_Delegate_Imp311(object p0, TreasureCategory p1, bool p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7292,7 +7202,7 @@
#endif
        }
        
        public UnityEngine.Vector3 __Gen_Delegate_Imp317(object p0, int p1)
        public UnityEngine.Vector3 __Gen_Delegate_Imp312(object p0, int p1)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7315,7 +7225,7 @@
#endif
        }
        
        public System.Collections.IEnumerator __Gen_Delegate_Imp318(object p0, object p1, float p2)
        public System.Collections.IEnumerator __Gen_Delegate_Imp313(object p0, object p1, float p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7339,7 +7249,7 @@
#endif
        }
        
        public Snxxz.UI.SignInModel __Gen_Delegate_Imp319(object p0)
        public Snxxz.UI.SignInModel __Gen_Delegate_Imp314(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)

 Lua/Gen/EnumWrap.cs

@@ -16,6 +16,2040 @@
{
    using Utils = XLua.Utils;
    
    public class JumpUITypeWrap
    {
        public static void __Register(RealStatePtr L)
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            Utils.BeginObjectRegister(typeof(JumpUIType), L, translator, 0, 0, 0, 0);
            Utils.EndObjectRegister(typeof(JumpUIType), L, translator, null, null, null, null, null);
			
            Utils.BeginClassRegister(typeof(JumpUIType), L, null, 333, 0, 0);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", JumpUIType.None);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RoleFunc1", JumpUIType.RoleFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RoleFunc2", JumpUIType.RoleFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RoleFunc3", JumpUIType.RoleFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RoleFunc4", JumpUIType.RoleFunc4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KnapSackFunc1", JumpUIType.KnapSackFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KnapSackFunc2", JumpUIType.KnapSackFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KnapSackFunc3", JumpUIType.KnapSackFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KnapSackFunc4", JumpUIType.KnapSackFunc4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillFunc1", JumpUIType.SkillFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillFunc2", JumpUIType.SkillFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillFunc2Type2", JumpUIType.SkillFunc2Type2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillFunc3", JumpUIType.SkillFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StrengthFunc1", JumpUIType.StrengthFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StrengthFunc2", JumpUIType.StrengthFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StrengthFunc3", JumpUIType.StrengthFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StrengthFunc4", JumpUIType.StrengthFunc4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipLowSuit", JumpUIType.EquipLowSuit);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StrengthFunc5", JumpUIType.StrengthFunc5);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipWashType2", JumpUIType.EquipWashType2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComposeFunc1", JumpUIType.ComposeFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComposeFunc2", JumpUIType.ComposeFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComposeFunc3", JumpUIType.ComposeFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComposeFunc4", JumpUIType.ComposeFunc4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComposeFunc5", JumpUIType.ComposeFunc5);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneFunc1", JumpUIType.RuneFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneFunc2", JumpUIType.RuneFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneFunc3", JumpUIType.RuneFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneFunc4", JumpUIType.RuneFunc4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionStore", JumpUIType.UnionStore);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionFunc1", JumpUIType.UnionFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionFunc2", JumpUIType.UnionFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionFunc3", JumpUIType.UnionFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionFunc4", JumpUIType.UnionFunc4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionFunc5", JumpUIType.UnionFunc5);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetFunc1", JumpUIType.PetFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetFunc2", JumpUIType.PetFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MountType2", JumpUIType.MountType2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetStone", JumpUIType.PetStone);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Treasure", JumpUIType.Treasure);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldChat", JumpUIType.WorldChat);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PrivateChat", JumpUIType.PrivateChat);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BountyInterface", JumpUIType.BountyInterface);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DailyQuestFunc1", JumpUIType.DailyQuestFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DailyQuestFunc2", JumpUIType.DailyQuestFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DailyQuestFunc3", JumpUIType.DailyQuestFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RoleTitle", JumpUIType.RoleTitle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealmFunc1", JumpUIType.RealmFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RolePoint", JumpUIType.RolePoint);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MainTask", JumpUIType.MainTask);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BigMap", JumpUIType.BigMap);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldMap", JumpUIType.WorldMap);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MountStone", JumpUIType.MountStone);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MountSkill", JumpUIType.MountSkill);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MountAppearance", JumpUIType.MountAppearance);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionBoss", JumpUIType.UnionBoss);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IceCrystal", JumpUIType.IceCrystal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyLand", JumpUIType.FairyLand);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GridExtend", JumpUIType.GridExtend);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StoreFunc1", JumpUIType.StoreFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StoreFunc2", JumpUIType.StoreFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StoreFunc3", JumpUIType.StoreFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StoreFunc4", JumpUIType.StoreFunc4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StoreFunc5", JumpUIType.StoreFunc5);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipRechargeFunc1", JumpUIType.VipRechargeFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipRechargeFunc2", JumpUIType.VipRechargeFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipRechargeFunc3", JumpUIType.VipRechargeFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipRechargeFunc4", JumpUIType.VipRechargeFunc4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipRechargeFunc5", JumpUIType.VipRechargeFunc5);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FindPreciousFrameFunc1", JumpUIType.FindPreciousFrameFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FindPreciousFrameFunc2", JumpUIType.FindPreciousFrameFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FindPreciousFrameFunc3", JumpUIType.FindPreciousFrameFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FindPreciousFrameFunc4", JumpUIType.FindPreciousFrameFunc4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FindPreciousFrameFunc5", JumpUIType.FindPreciousFrameFunc5);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FindPreciousFrameFunc6", JumpUIType.FindPreciousFrameFunc6);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MarketFunc1", JumpUIType.MarketFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MarketFunc2", JumpUIType.MarketFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MarketFunc3", JumpUIType.MarketFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BlastFurnaceFunc1", JumpUIType.BlastFurnaceFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MyTeamType1", JumpUIType.MyTeamType1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TeamListType1", JumpUIType.TeamListType1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipExperience", JumpUIType.VipExperience);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneTower", JumpUIType.RuneTower);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WelfareFunc1", JumpUIType.WelfareFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WelfareFunc2", JumpUIType.WelfareFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SystemSettingFunc1", JumpUIType.SystemSettingFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RebornOpenBag", JumpUIType.RebornOpenBag);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RebornOpenAddPoint", JumpUIType.RebornOpenAddPoint);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RebornOpenHourse", JumpUIType.RebornOpenHourse);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RebornOpenStrength", JumpUIType.RebornOpenStrength);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RebornOpenPet", JumpUIType.RebornOpenPet);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RedPacket", JumpUIType.RedPacket);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureFunc1", JumpUIType.TreasureFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureFunc2", JumpUIType.TreasureFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Type1TreasureFunc1", JumpUIType.Type1TreasureFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Type1TreasureFunc2", JumpUIType.Type1TreasureFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionWarehouse", JumpUIType.UnionWarehouse);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionHall", JumpUIType.UnionHall);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionMethod", JumpUIType.UnionMethod);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionTask", JumpUIType.UnionTask);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureFunc3", JumpUIType.TreasureFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealmPractice1", JumpUIType.RealmPractice1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealmPractice2", JumpUIType.RealmPractice2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionActive1", JumpUIType.UnionActive1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionActive2", JumpUIType.UnionActive2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddFriend1", JumpUIType.AddFriend1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddFriend2", JumpUIType.AddFriend2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionChat1", JumpUIType.UnionChat1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionChat2", JumpUIType.UnionChat2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TicketCompose1", JumpUIType.TicketCompose1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TicketCompose2", JumpUIType.TicketCompose2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UseNormalDrug", JumpUIType.UseNormalDrug);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XianBaguaIntr", JumpUIType.XianBaguaIntr);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionTask2", JumpUIType.UnionTask2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerActivityFunc2_1", JumpUIType.OpenServerActivityFunc2_1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerActivityFunc2_2", JumpUIType.OpenServerActivityFunc2_2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FirstRecharge", JumpUIType.FirstRecharge);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KnapSackFunc1Type2", JumpUIType.KnapSackFunc1Type2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StrengthFunc1Type2", JumpUIType.StrengthFunc1Type2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KnapSackFunc5", JumpUIType.KnapSackFunc5);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureFindHostFunc1", JumpUIType.TreasureFindHostFunc1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureFindHostFunc1Type2", JumpUIType.TreasureFindHostFunc1Type2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureFindHostFunc2", JumpUIType.TreasureFindHostFunc2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureFindHostFunc2Type2", JumpUIType.TreasureFindHostFunc2Type2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureFindHostFunc3", JumpUIType.TreasureFindHostFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureFindHostFunc3Type2", JumpUIType.TreasureFindHostFunc3Type2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureFindHost_LLBT_Type1", JumpUIType.TreasureFindHost_LLBT_Type1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureFindHost_LLBT_Type2", JumpUIType.TreasureFindHost_LLBT_Type2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerGift", JumpUIType.OpenServerGift);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WelfareFunc3", JumpUIType.WelfareFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alchemyrescripte104", JumpUIType.Alchemyrescripte104);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alchemyrescripte105", JumpUIType.Alchemyrescripte105);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipRechargeVip3", JumpUIType.VipRechargeVip3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipRechargeVip2", JumpUIType.VipRechargeVip2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipRechargeVip4", JumpUIType.VipRechargeVip4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipRechargeVip5", JumpUIType.VipRechargeVip5);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipRechargeVip6", JumpUIType.VipRechargeVip6);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipRechargeVip7", JumpUIType.VipRechargeVip7);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipRechargeVip8", JumpUIType.VipRechargeVip8);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipRechargeVip9", JumpUIType.VipRechargeVip9);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipRechargeVip10", JumpUIType.VipRechargeVip10);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlotTaskFunc3", JumpUIType.PlotTaskFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerMountRank", JumpUIType.OpenServerMountRank);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AncientBattle", JumpUIType.AncientBattle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XMZZBattle", JumpUIType.XMZZBattle);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipRechargeVip1", JumpUIType.VipRechargeVip1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Daily_Kirin", JumpUIType.Daily_Kirin);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AttackMagicianType1", JumpUIType.AttackMagicianType1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AttackMagicianType2", JumpUIType.AttackMagicianType2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerRank", JumpUIType.OpenServerRank);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Daily_BountyMission", JumpUIType.Daily_BountyMission);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Daily_IceCrystal", JumpUIType.Daily_IceCrystal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Daily_Trial", JumpUIType.Daily_Trial);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Daily_FairyLand", JumpUIType.Daily_FairyLand);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Daily_GuardSky", JumpUIType.Daily_GuardSky);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Daily_Demon", JumpUIType.Daily_Demon);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Daily_ElderGodArea", JumpUIType.Daily_ElderGodArea);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Daily_AncientBattleGround", JumpUIType.Daily_AncientBattleGround);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Daily_EmperorRelic", JumpUIType.Daily_EmperorRelic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureSoul", JumpUIType.TreasureSoul);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LootPreciousFrameSpec", JumpUIType.LootPreciousFrameSpec);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneTowerSpec", JumpUIType.RuneTowerSpec);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Daily_FairyTask", JumpUIType.Daily_FairyTask);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoSoul_BenYuan", JumpUIType.FaBaoSoul_BenYuan);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoSoul_FengMo", JumpUIType.FaBaoSoul_FengMo);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoSoul_Strength", JumpUIType.FaBaoSoul_Strength);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoSoul_Rune", JumpUIType.FaBaoSoul_Rune);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoSoul_Mount", JumpUIType.FaBaoSoul_Mount);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoSoul_Pet", JumpUIType.FaBaoSoul_Pet);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoSoul_Boss", JumpUIType.FaBaoSoul_Boss);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoSoul_Wings", JumpUIType.FaBaoSoul_Wings);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoSoul_Suit", JumpUIType.FaBaoSoul_Suit);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoSoul_Wash", JumpUIType.FaBaoSoul_Wash);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ConsumreRebate", JumpUIType.ConsumreRebate);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OSTimeLimitGift", JumpUIType.OSTimeLimitGift);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WelfareFunc2Type2", JumpUIType.WelfareFunc2Type2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LimitedTimePackage", JumpUIType.LimitedTimePackage);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BossReborn", JumpUIType.BossReborn);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FlashSale", JumpUIType.FlashSale);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BestXB", JumpUIType.BestXB);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneXB", JumpUIType.RuneXB);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XBStore", JumpUIType.XBStore);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XBWarehouse", JumpUIType.XBWarehouse);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BestXBType2", JumpUIType.BestXBType2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneXBType2", JumpUIType.RuneXBType2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XBStoreType2", JumpUIType.XBStoreType2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XBWarehouseType2", JumpUIType.XBWarehouseType2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TrialExchange", JumpUIType.TrialExchange);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComposeTicketFairy", JumpUIType.ComposeTicketFairy);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComposeTicketIce", JumpUIType.ComposeTicketIce);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComposeTicketGod", JumpUIType.ComposeTicketGod);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TrialDungeonSelect", JumpUIType.TrialDungeonSelect);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TrialDungeonSelect1", JumpUIType.TrialDungeonSelect1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TrialDungeonSelect2", JumpUIType.TrialDungeonSelect2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TrialDungeonSelect3", JumpUIType.TrialDungeonSelect3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FindPreciousFrameFunc4Type2", JumpUIType.FindPreciousFrameFunc4Type2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FindPreciousFrameFunc2Type2", JumpUIType.FindPreciousFrameFunc2Type2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyGrabBoss", JumpUIType.FairyGrabBoss);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerGift1", JumpUIType.OpenServerGift1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerGift2", JumpUIType.OpenServerGift2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerGift3", JumpUIType.OpenServerGift3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerGift4", JumpUIType.OpenServerGift4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Kylin", JumpUIType.Kylin);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Kylin1", JumpUIType.Kylin1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Kylin2", JumpUIType.Kylin2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Kylin3", JumpUIType.Kylin3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Kylin4", JumpUIType.Kylin4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Kylin5", JumpUIType.Kylin5);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Kylin6", JumpUIType.Kylin6);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PrayforDrug", JumpUIType.PrayforDrug);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose1", JumpUIType.EquipCompose1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose2", JumpUIType.EquipCompose2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose3", JumpUIType.EquipCompose3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose4", JumpUIType.EquipCompose4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CeremonyRecharge", JumpUIType.CeremonyRecharge);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CeremonyFire", JumpUIType.CeremonyFire);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CeremonyPeopleToHi", JumpUIType.CeremonyPeopleToHi);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CeremonyOutof", JumpUIType.CeremonyOutof);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DogzFunc1Type1", JumpUIType.DogzFunc1Type1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DogzFunc1Type2", JumpUIType.DogzFunc1Type2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DogzFunc2Type1", JumpUIType.DogzFunc2Type1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DogzFunc2Type2", JumpUIType.DogzFunc2Type2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BindGoldWheel", JumpUIType.BindGoldWheel);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FlashRushToBuy", JumpUIType.FlashRushToBuy);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipHighSuit", JumpUIType.EquipHighSuit);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Team_TrialDungeon", JumpUIType.Team_TrialDungeon);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Team_EmperorRelic", JumpUIType.Team_EmperorRelic);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServer_AccumulateRecharge", JumpUIType.OpenServer_AccumulateRecharge);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DungeonAssitCheckIn", JumpUIType.DungeonAssitCheckIn);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Chat_Trumpet", JumpUIType.Chat_Trumpet);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LifeMagicianPreview", JumpUIType.LifeMagicianPreview);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AttackMagicianPreview", JumpUIType.AttackMagicianPreview);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DefenceMagicianPreview", JumpUIType.DefenceMagicianPreview);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XianYuanCoinsStore", JumpUIType.XianYuanCoinsStore);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TrialExchange2", JumpUIType.TrialExchange2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose265", JumpUIType.EquipCompose265);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose266", JumpUIType.EquipCompose266);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose267", JumpUIType.EquipCompose267);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose268", JumpUIType.EquipCompose268);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose269", JumpUIType.EquipCompose269);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose270", JumpUIType.EquipCompose270);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GatherSoul271", JumpUIType.GatherSoul271);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GatherSoul272", JumpUIType.GatherSoul272);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GatherSoul273", JumpUIType.GatherSoul273);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Daily_GatherSoul274", JumpUIType.Daily_GatherSoul274);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossServerOneVsOne275", JumpUIType.CrossServerOneVsOne275);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossServerOneVsOne276", JumpUIType.CrossServerOneVsOne276);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossServerOneVsOne277", JumpUIType.CrossServerOneVsOne277);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossServerOneVsOne278", JumpUIType.CrossServerOneVsOne278);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossServerOneVsOne279", JumpUIType.CrossServerOneVsOne279);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FashionDress280", JumpUIType.FashionDress280);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SevenDaysTour281", JumpUIType.SevenDaysTour281);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SevenDaysTour282", JumpUIType.SevenDaysTour282);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SevenDaysTour283", JumpUIType.SevenDaysTour283);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SevenDaysTour284", JumpUIType.SevenDaysTour284);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SevenDaysTour285", JumpUIType.SevenDaysTour285);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SevenDaysTour286", JumpUIType.SevenDaysTour286);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SevenDaysTour287", JumpUIType.SevenDaysTour287);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JadeDynastyTower288", JumpUIType.JadeDynastyTower288);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JadeDynastyTowerRank289", JumpUIType.JadeDynastyTowerRank289);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JadeDynastyBoss290", JumpUIType.JadeDynastyBoss290);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose291", JumpUIType.EquipCompose291);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JadeDynastyEquip292", JumpUIType.JadeDynastyEquip292);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose293", JumpUIType.EquipCompose293);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose294", JumpUIType.EquipCompose294);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose295", JumpUIType.EquipCompose295);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose296", JumpUIType.EquipCompose296);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose297", JumpUIType.EquipCompose297);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose298", JumpUIType.EquipCompose298);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NewYearTour299", JumpUIType.NewYearTour299);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NewYearTour300", JumpUIType.NewYearTour300);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NewYearTour301", JumpUIType.NewYearTour301);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NewYearTour302", JumpUIType.NewYearTour302);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FestivalRedBag303", JumpUIType.FestivalRedBag303);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JadeDynastyGem304", JumpUIType.JadeDynastyGem304);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ToolCompose305", JumpUIType.ToolCompose305);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LuckyTreasure306", JumpUIType.LuckyTreasure306);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LoginReward307", JumpUIType.LoginReward307);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AllianceBoss1", JumpUIType.AllianceBoss1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AllianceBoss2", JumpUIType.AllianceBoss2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyAuction", JumpUIType.FairyAuction);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureSkill", JumpUIType.TreasureSkill);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alchemy1", JumpUIType.Alchemy1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alchemy2", JumpUIType.Alchemy2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alchemy3", JumpUIType.Alchemy3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alchemy4", JumpUIType.Alchemy4);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alchemy5", JumpUIType.Alchemy5);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealmEquip1", JumpUIType.RealmEquip1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alchemy6", JumpUIType.Alchemy6);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FullServerAuction", JumpUIType.FullServerAuction);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AlchemyNormal", JumpUIType.AlchemyNormal);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AlchemyFairy", JumpUIType.AlchemyFairy);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RolePromote", JumpUIType.RolePromote);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UseFairyDrug", JumpUIType.UseFairyDrug);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MonthInvest", JumpUIType.MonthInvest);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WeekInvest", JumpUIType.WeekInvest);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyStore1", JumpUIType.FairyStore1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alchemy7", JumpUIType.Alchemy7);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alchemy8", JumpUIType.Alchemy8);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alchemy9", JumpUIType.Alchemy9);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldBossCountWin", JumpUIType.WorldBossCountWin);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealmEquip", JumpUIType.RealmEquip);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExchangeActiveToken", JumpUIType.ExchangeActiveToken);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Daily_FairyFeast", JumpUIType.Daily_FairyFeast);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Daily_FairyMatches", JumpUIType.Daily_FairyMatches);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossServerBoss", JumpUIType.CrossServerBoss);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alchemy10", JumpUIType.Alchemy10);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alchemy11", JumpUIType.Alchemy11);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DhszTs", JumpUIType.DhszTs);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HyqTs", JumpUIType.HyqTs);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GyzTs", JumpUIType.GyzTs);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LqhTs", JumpUIType.LqhTs);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlyTs", JumpUIType.PlyTs);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XhqTs", JumpUIType.XhqTs);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DhzTs", JumpUIType.DhzTs);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZjhlTs", JumpUIType.ZjhlTs);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "YldTs", JumpUIType.YldTs);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StfTs", JumpUIType.StfTs);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XyjJs", JumpUIType.XyjJs);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BGLJS", JumpUIType.BGLJS);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LFZJS", JumpUIType.LFZJS);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "YLJJS", JumpUIType.YLJJS);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SBXZJS", JumpUIType.SBXZJS);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KLJJS", JumpUIType.KLJJS);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TJYJS", JumpUIType.TJYJS);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Type1TreasureFunc3", JumpUIType.Type1TreasureFunc3);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LLBT", JumpUIType.LLBT);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FYZJTyp1", JumpUIType.FYZJTyp1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FYZJTyp2", JumpUIType.FYZJTyp2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SHLTyp1", JumpUIType.SHLTyp1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SHLTyp2", JumpUIType.SHLTyp2);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HazyRegion", JumpUIType.HazyRegion);
            
            Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
            Utils.EndClassRegister(typeof(JumpUIType), L, translator);
        }
		
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CastFrom(RealStatePtr L)
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            LuaTypes lua_type = LuaAPI.lua_type(L, 1);
            if (lua_type == LuaTypes.LUA_TNUMBER)
            {
                translator.PushJumpUIType(L, (JumpUIType)LuaAPI.xlua_tointeger(L, 1));
            }
			
            else if(lua_type == LuaTypes.LUA_TSTRING)
            {
                if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
                {
                    translator.PushJumpUIType(L, JumpUIType.None);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RoleFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RoleFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RoleFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RoleFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RoleFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RoleFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RoleFunc4"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RoleFunc4);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "KnapSackFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.KnapSackFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "KnapSackFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.KnapSackFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "KnapSackFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.KnapSackFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "KnapSackFunc4"))
                {
                    translator.PushJumpUIType(L, JumpUIType.KnapSackFunc4);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.SkillFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.SkillFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillFunc2Type2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.SkillFunc2Type2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.SkillFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "StrengthFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.StrengthFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "StrengthFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.StrengthFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "StrengthFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.StrengthFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "StrengthFunc4"))
                {
                    translator.PushJumpUIType(L, JumpUIType.StrengthFunc4);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipLowSuit"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipLowSuit);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "StrengthFunc5"))
                {
                    translator.PushJumpUIType(L, JumpUIType.StrengthFunc5);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipWashType2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipWashType2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "ComposeFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.ComposeFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "ComposeFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.ComposeFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "ComposeFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.ComposeFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "ComposeFunc4"))
                {
                    translator.PushJumpUIType(L, JumpUIType.ComposeFunc4);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "ComposeFunc5"))
                {
                    translator.PushJumpUIType(L, JumpUIType.ComposeFunc5);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RuneFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RuneFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RuneFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneFunc4"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RuneFunc4);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionStore"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionStore);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionFunc4"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionFunc4);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionFunc5"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionFunc5);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "PetFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.PetFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "PetFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.PetFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "MountType2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.MountType2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "PetStone"))
                {
                    translator.PushJumpUIType(L, JumpUIType.PetStone);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Treasure"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Treasure);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldChat"))
                {
                    translator.PushJumpUIType(L, JumpUIType.WorldChat);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "PrivateChat"))
                {
                    translator.PushJumpUIType(L, JumpUIType.PrivateChat);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "BountyInterface"))
                {
                    translator.PushJumpUIType(L, JumpUIType.BountyInterface);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "DailyQuestFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.DailyQuestFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "DailyQuestFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.DailyQuestFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "DailyQuestFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.DailyQuestFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RoleTitle"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RoleTitle);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RealmFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RealmFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RolePoint"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RolePoint);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "MainTask"))
                {
                    translator.PushJumpUIType(L, JumpUIType.MainTask);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "BigMap"))
                {
                    translator.PushJumpUIType(L, JumpUIType.BigMap);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldMap"))
                {
                    translator.PushJumpUIType(L, JumpUIType.WorldMap);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "MountStone"))
                {
                    translator.PushJumpUIType(L, JumpUIType.MountStone);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "MountSkill"))
                {
                    translator.PushJumpUIType(L, JumpUIType.MountSkill);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "MountAppearance"))
                {
                    translator.PushJumpUIType(L, JumpUIType.MountAppearance);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionBoss"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionBoss);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "IceCrystal"))
                {
                    translator.PushJumpUIType(L, JumpUIType.IceCrystal);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyLand"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FairyLand);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "GridExtend"))
                {
                    translator.PushJumpUIType(L, JumpUIType.GridExtend);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "StoreFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.StoreFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "StoreFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.StoreFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "StoreFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.StoreFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "StoreFunc4"))
                {
                    translator.PushJumpUIType(L, JumpUIType.StoreFunc4);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "StoreFunc5"))
                {
                    translator.PushJumpUIType(L, JumpUIType.StoreFunc5);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipRechargeFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipRechargeFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipRechargeFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipRechargeFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipRechargeFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipRechargeFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipRechargeFunc4"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipRechargeFunc4);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipRechargeFunc5"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipRechargeFunc5);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FindPreciousFrameFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FindPreciousFrameFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FindPreciousFrameFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FindPreciousFrameFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FindPreciousFrameFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FindPreciousFrameFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FindPreciousFrameFunc4"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FindPreciousFrameFunc4);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FindPreciousFrameFunc5"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FindPreciousFrameFunc5);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FindPreciousFrameFunc6"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FindPreciousFrameFunc6);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "MarketFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.MarketFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "MarketFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.MarketFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "MarketFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.MarketFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "BlastFurnaceFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.BlastFurnaceFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "MyTeamType1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.MyTeamType1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TeamListType1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TeamListType1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipExperience"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipExperience);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneTower"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RuneTower);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "WelfareFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.WelfareFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "WelfareFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.WelfareFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "SystemSettingFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.SystemSettingFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RebornOpenBag"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RebornOpenBag);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RebornOpenAddPoint"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RebornOpenAddPoint);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RebornOpenHourse"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RebornOpenHourse);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RebornOpenStrength"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RebornOpenStrength);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RebornOpenPet"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RebornOpenPet);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RedPacket"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RedPacket);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TreasureFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TreasureFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Type1TreasureFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Type1TreasureFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Type1TreasureFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Type1TreasureFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionWarehouse"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionWarehouse);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionHall"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionHall);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionMethod"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionMethod);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionTask"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionTask);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TreasureFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RealmPractice1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RealmPractice1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RealmPractice2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RealmPractice2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionActive1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionActive1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionActive2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionActive2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "AddFriend1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.AddFriend1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "AddFriend2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.AddFriend2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionChat1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionChat1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionChat2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionChat2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TicketCompose1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TicketCompose1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TicketCompose2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TicketCompose2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UseNormalDrug"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UseNormalDrug);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "XianBaguaIntr"))
                {
                    translator.PushJumpUIType(L, JumpUIType.XianBaguaIntr);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionTask2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UnionTask2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerActivityFunc2_1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.OpenServerActivityFunc2_1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerActivityFunc2_2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.OpenServerActivityFunc2_2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FirstRecharge"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FirstRecharge);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "KnapSackFunc1Type2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.KnapSackFunc1Type2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "StrengthFunc1Type2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.StrengthFunc1Type2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "KnapSackFunc5"))
                {
                    translator.PushJumpUIType(L, JumpUIType.KnapSackFunc5);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureFindHostFunc1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TreasureFindHostFunc1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureFindHostFunc1Type2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TreasureFindHostFunc1Type2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureFindHostFunc2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TreasureFindHostFunc2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureFindHostFunc2Type2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TreasureFindHostFunc2Type2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureFindHostFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TreasureFindHostFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureFindHostFunc3Type2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TreasureFindHostFunc3Type2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureFindHost_LLBT_Type1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TreasureFindHost_LLBT_Type1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureFindHost_LLBT_Type2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TreasureFindHost_LLBT_Type2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerGift"))
                {
                    translator.PushJumpUIType(L, JumpUIType.OpenServerGift);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "WelfareFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.WelfareFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Alchemyrescripte104"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Alchemyrescripte104);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Alchemyrescripte105"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Alchemyrescripte105);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipRechargeVip3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipRechargeVip3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipRechargeVip2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipRechargeVip2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipRechargeVip4"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipRechargeVip4);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipRechargeVip5"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipRechargeVip5);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipRechargeVip6"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipRechargeVip6);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipRechargeVip7"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipRechargeVip7);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipRechargeVip8"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipRechargeVip8);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipRechargeVip9"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipRechargeVip9);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipRechargeVip10"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipRechargeVip10);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "PlotTaskFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.PlotTaskFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerMountRank"))
                {
                    translator.PushJumpUIType(L, JumpUIType.OpenServerMountRank);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "AncientBattle"))
                {
                    translator.PushJumpUIType(L, JumpUIType.AncientBattle);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "XMZZBattle"))
                {
                    translator.PushJumpUIType(L, JumpUIType.XMZZBattle);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "VipRechargeVip1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.VipRechargeVip1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Daily_Kirin"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Daily_Kirin);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "AttackMagicianType1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.AttackMagicianType1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "AttackMagicianType2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.AttackMagicianType2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerRank"))
                {
                    translator.PushJumpUIType(L, JumpUIType.OpenServerRank);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Daily_BountyMission"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Daily_BountyMission);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Daily_IceCrystal"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Daily_IceCrystal);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Daily_Trial"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Daily_Trial);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Daily_FairyLand"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Daily_FairyLand);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Daily_GuardSky"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Daily_GuardSky);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Daily_Demon"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Daily_Demon);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Daily_ElderGodArea"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Daily_ElderGodArea);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Daily_AncientBattleGround"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Daily_AncientBattleGround);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Daily_EmperorRelic"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Daily_EmperorRelic);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureSoul"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TreasureSoul);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "LootPreciousFrameSpec"))
                {
                    translator.PushJumpUIType(L, JumpUIType.LootPreciousFrameSpec);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneTowerSpec"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RuneTowerSpec);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Daily_FairyTask"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Daily_FairyTask);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoSoul_BenYuan"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FaBaoSoul_BenYuan);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoSoul_FengMo"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FaBaoSoul_FengMo);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoSoul_Strength"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FaBaoSoul_Strength);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoSoul_Rune"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FaBaoSoul_Rune);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoSoul_Mount"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FaBaoSoul_Mount);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoSoul_Pet"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FaBaoSoul_Pet);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoSoul_Boss"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FaBaoSoul_Boss);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoSoul_Wings"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FaBaoSoul_Wings);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoSoul_Suit"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FaBaoSoul_Suit);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoSoul_Wash"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FaBaoSoul_Wash);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "ConsumreRebate"))
                {
                    translator.PushJumpUIType(L, JumpUIType.ConsumreRebate);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "OSTimeLimitGift"))
                {
                    translator.PushJumpUIType(L, JumpUIType.OSTimeLimitGift);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "WelfareFunc2Type2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.WelfareFunc2Type2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "LimitedTimePackage"))
                {
                    translator.PushJumpUIType(L, JumpUIType.LimitedTimePackage);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "BossReborn"))
                {
                    translator.PushJumpUIType(L, JumpUIType.BossReborn);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FlashSale"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FlashSale);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "BestXB"))
                {
                    translator.PushJumpUIType(L, JumpUIType.BestXB);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneXB"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RuneXB);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "XBStore"))
                {
                    translator.PushJumpUIType(L, JumpUIType.XBStore);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "XBWarehouse"))
                {
                    translator.PushJumpUIType(L, JumpUIType.XBWarehouse);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "BestXBType2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.BestXBType2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneXBType2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RuneXBType2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "XBStoreType2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.XBStoreType2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "XBWarehouseType2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.XBWarehouseType2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TrialExchange"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TrialExchange);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "ComposeTicketFairy"))
                {
                    translator.PushJumpUIType(L, JumpUIType.ComposeTicketFairy);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "ComposeTicketIce"))
                {
                    translator.PushJumpUIType(L, JumpUIType.ComposeTicketIce);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "ComposeTicketGod"))
                {
                    translator.PushJumpUIType(L, JumpUIType.ComposeTicketGod);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TrialDungeonSelect"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TrialDungeonSelect);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TrialDungeonSelect1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TrialDungeonSelect1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TrialDungeonSelect2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TrialDungeonSelect2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TrialDungeonSelect3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TrialDungeonSelect3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FindPreciousFrameFunc4Type2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FindPreciousFrameFunc4Type2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FindPreciousFrameFunc2Type2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FindPreciousFrameFunc2Type2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyGrabBoss"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FairyGrabBoss);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerGift1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.OpenServerGift1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerGift2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.OpenServerGift2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerGift3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.OpenServerGift3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerGift4"))
                {
                    translator.PushJumpUIType(L, JumpUIType.OpenServerGift4);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Kylin"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Kylin);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Kylin1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Kylin1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Kylin2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Kylin2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Kylin3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Kylin3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Kylin4"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Kylin4);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Kylin5"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Kylin5);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Kylin6"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Kylin6);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "PrayforDrug"))
                {
                    translator.PushJumpUIType(L, JumpUIType.PrayforDrug);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose4"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose4);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "CeremonyRecharge"))
                {
                    translator.PushJumpUIType(L, JumpUIType.CeremonyRecharge);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "CeremonyFire"))
                {
                    translator.PushJumpUIType(L, JumpUIType.CeremonyFire);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "CeremonyPeopleToHi"))
                {
                    translator.PushJumpUIType(L, JumpUIType.CeremonyPeopleToHi);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "CeremonyOutof"))
                {
                    translator.PushJumpUIType(L, JumpUIType.CeremonyOutof);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "DogzFunc1Type1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.DogzFunc1Type1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "DogzFunc1Type2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.DogzFunc1Type2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "DogzFunc2Type1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.DogzFunc2Type1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "DogzFunc2Type2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.DogzFunc2Type2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "BindGoldWheel"))
                {
                    translator.PushJumpUIType(L, JumpUIType.BindGoldWheel);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FlashRushToBuy"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FlashRushToBuy);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipHighSuit"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipHighSuit);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Team_TrialDungeon"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Team_TrialDungeon);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Team_EmperorRelic"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Team_EmperorRelic);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServer_AccumulateRecharge"))
                {
                    translator.PushJumpUIType(L, JumpUIType.OpenServer_AccumulateRecharge);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "DungeonAssitCheckIn"))
                {
                    translator.PushJumpUIType(L, JumpUIType.DungeonAssitCheckIn);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Chat_Trumpet"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Chat_Trumpet);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "LifeMagicianPreview"))
                {
                    translator.PushJumpUIType(L, JumpUIType.LifeMagicianPreview);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "AttackMagicianPreview"))
                {
                    translator.PushJumpUIType(L, JumpUIType.AttackMagicianPreview);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "DefenceMagicianPreview"))
                {
                    translator.PushJumpUIType(L, JumpUIType.DefenceMagicianPreview);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "XianYuanCoinsStore"))
                {
                    translator.PushJumpUIType(L, JumpUIType.XianYuanCoinsStore);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TrialExchange2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TrialExchange2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose265"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose265);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose266"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose266);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose267"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose267);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose268"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose268);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose269"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose269);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose270"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose270);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "GatherSoul271"))
                {
                    translator.PushJumpUIType(L, JumpUIType.GatherSoul271);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "GatherSoul272"))
                {
                    translator.PushJumpUIType(L, JumpUIType.GatherSoul272);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "GatherSoul273"))
                {
                    translator.PushJumpUIType(L, JumpUIType.GatherSoul273);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Daily_GatherSoul274"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Daily_GatherSoul274);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossServerOneVsOne275"))
                {
                    translator.PushJumpUIType(L, JumpUIType.CrossServerOneVsOne275);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossServerOneVsOne276"))
                {
                    translator.PushJumpUIType(L, JumpUIType.CrossServerOneVsOne276);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossServerOneVsOne277"))
                {
                    translator.PushJumpUIType(L, JumpUIType.CrossServerOneVsOne277);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossServerOneVsOne278"))
                {
                    translator.PushJumpUIType(L, JumpUIType.CrossServerOneVsOne278);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossServerOneVsOne279"))
                {
                    translator.PushJumpUIType(L, JumpUIType.CrossServerOneVsOne279);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FashionDress280"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FashionDress280);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "SevenDaysTour281"))
                {
                    translator.PushJumpUIType(L, JumpUIType.SevenDaysTour281);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "SevenDaysTour282"))
                {
                    translator.PushJumpUIType(L, JumpUIType.SevenDaysTour282);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "SevenDaysTour283"))
                {
                    translator.PushJumpUIType(L, JumpUIType.SevenDaysTour283);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "SevenDaysTour284"))
                {
                    translator.PushJumpUIType(L, JumpUIType.SevenDaysTour284);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "SevenDaysTour285"))
                {
                    translator.PushJumpUIType(L, JumpUIType.SevenDaysTour285);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "SevenDaysTour286"))
                {
                    translator.PushJumpUIType(L, JumpUIType.SevenDaysTour286);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "SevenDaysTour287"))
                {
                    translator.PushJumpUIType(L, JumpUIType.SevenDaysTour287);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "JadeDynastyTower288"))
                {
                    translator.PushJumpUIType(L, JumpUIType.JadeDynastyTower288);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "JadeDynastyTowerRank289"))
                {
                    translator.PushJumpUIType(L, JumpUIType.JadeDynastyTowerRank289);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "JadeDynastyBoss290"))
                {
                    translator.PushJumpUIType(L, JumpUIType.JadeDynastyBoss290);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose291"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose291);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "JadeDynastyEquip292"))
                {
                    translator.PushJumpUIType(L, JumpUIType.JadeDynastyEquip292);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose293"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose293);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose294"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose294);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose295"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose295);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose296"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose296);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose297"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose297);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose298"))
                {
                    translator.PushJumpUIType(L, JumpUIType.EquipCompose298);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "NewYearTour299"))
                {
                    translator.PushJumpUIType(L, JumpUIType.NewYearTour299);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "NewYearTour300"))
                {
                    translator.PushJumpUIType(L, JumpUIType.NewYearTour300);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "NewYearTour301"))
                {
                    translator.PushJumpUIType(L, JumpUIType.NewYearTour301);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "NewYearTour302"))
                {
                    translator.PushJumpUIType(L, JumpUIType.NewYearTour302);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FestivalRedBag303"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FestivalRedBag303);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "JadeDynastyGem304"))
                {
                    translator.PushJumpUIType(L, JumpUIType.JadeDynastyGem304);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "ToolCompose305"))
                {
                    translator.PushJumpUIType(L, JumpUIType.ToolCompose305);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "LuckyTreasure306"))
                {
                    translator.PushJumpUIType(L, JumpUIType.LuckyTreasure306);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "LoginReward307"))
                {
                    translator.PushJumpUIType(L, JumpUIType.LoginReward307);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "AllianceBoss1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.AllianceBoss1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "AllianceBoss2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.AllianceBoss2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyAuction"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FairyAuction);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureSkill"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TreasureSkill);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Alchemy1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Alchemy1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Alchemy2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Alchemy2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Alchemy3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Alchemy3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Alchemy4"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Alchemy4);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Alchemy5"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Alchemy5);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RealmEquip1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RealmEquip1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Alchemy6"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Alchemy6);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FullServerAuction"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FullServerAuction);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "AlchemyNormal"))
                {
                    translator.PushJumpUIType(L, JumpUIType.AlchemyNormal);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "AlchemyFairy"))
                {
                    translator.PushJumpUIType(L, JumpUIType.AlchemyFairy);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RolePromote"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RolePromote);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "UseFairyDrug"))
                {
                    translator.PushJumpUIType(L, JumpUIType.UseFairyDrug);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "MonthInvest"))
                {
                    translator.PushJumpUIType(L, JumpUIType.MonthInvest);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "WeekInvest"))
                {
                    translator.PushJumpUIType(L, JumpUIType.WeekInvest);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyStore1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FairyStore1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Alchemy7"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Alchemy7);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Alchemy8"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Alchemy8);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Alchemy9"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Alchemy9);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldBossCountWin"))
                {
                    translator.PushJumpUIType(L, JumpUIType.WorldBossCountWin);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "RealmEquip"))
                {
                    translator.PushJumpUIType(L, JumpUIType.RealmEquip);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "ExchangeActiveToken"))
                {
                    translator.PushJumpUIType(L, JumpUIType.ExchangeActiveToken);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Daily_FairyFeast"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Daily_FairyFeast);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Daily_FairyMatches"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Daily_FairyMatches);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossServerBoss"))
                {
                    translator.PushJumpUIType(L, JumpUIType.CrossServerBoss);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Alchemy10"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Alchemy10);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Alchemy11"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Alchemy11);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "DhszTs"))
                {
                    translator.PushJumpUIType(L, JumpUIType.DhszTs);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "HyqTs"))
                {
                    translator.PushJumpUIType(L, JumpUIType.HyqTs);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "GyzTs"))
                {
                    translator.PushJumpUIType(L, JumpUIType.GyzTs);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "LqhTs"))
                {
                    translator.PushJumpUIType(L, JumpUIType.LqhTs);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "PlyTs"))
                {
                    translator.PushJumpUIType(L, JumpUIType.PlyTs);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "XhqTs"))
                {
                    translator.PushJumpUIType(L, JumpUIType.XhqTs);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "DhzTs"))
                {
                    translator.PushJumpUIType(L, JumpUIType.DhzTs);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "ZjhlTs"))
                {
                    translator.PushJumpUIType(L, JumpUIType.ZjhlTs);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "YldTs"))
                {
                    translator.PushJumpUIType(L, JumpUIType.YldTs);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "StfTs"))
                {
                    translator.PushJumpUIType(L, JumpUIType.StfTs);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "XyjJs"))
                {
                    translator.PushJumpUIType(L, JumpUIType.XyjJs);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "BGLJS"))
                {
                    translator.PushJumpUIType(L, JumpUIType.BGLJS);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "LFZJS"))
                {
                    translator.PushJumpUIType(L, JumpUIType.LFZJS);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "YLJJS"))
                {
                    translator.PushJumpUIType(L, JumpUIType.YLJJS);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "SBXZJS"))
                {
                    translator.PushJumpUIType(L, JumpUIType.SBXZJS);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "KLJJS"))
                {
                    translator.PushJumpUIType(L, JumpUIType.KLJJS);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "TJYJS"))
                {
                    translator.PushJumpUIType(L, JumpUIType.TJYJS);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Type1TreasureFunc3"))
                {
                    translator.PushJumpUIType(L, JumpUIType.Type1TreasureFunc3);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "LLBT"))
                {
                    translator.PushJumpUIType(L, JumpUIType.LLBT);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FYZJTyp1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FYZJTyp1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "FYZJTyp2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.FYZJTyp2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "SHLTyp1"))
                {
                    translator.PushJumpUIType(L, JumpUIType.SHLTyp1);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "SHLTyp2"))
                {
                    translator.PushJumpUIType(L, JumpUIType.SHLTyp2);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "HazyRegion"))
                {
                    translator.PushJumpUIType(L, JumpUIType.HazyRegion);
                }
                else
                {
                    return LuaAPI.luaL_error(L, "invalid string for JumpUIType!");
                }
            }
			
            else
            {
                return LuaAPI.luaL_error(L, "invalid lua type for JumpUIType! Expect number or string, got + " + lua_type);
            }

            return 1;
        }
    }
    
    public class E_ActorClassTypeWrap
    {
        public static void __Register(RealStatePtr L)

 Lua/Gen/SnxxzUIBossHomeModelWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.BossHomeModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 10, 6, 5);
            Utils.BeginObjectRegister(type, L, translator, 0, 11, 6, 5);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnInit", _m_UnInit);
@@ -34,6 +34,7 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "bossHomeFloorSelectedEvent", _e_bossHomeFloorSelectedEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "bossSelectedEvent", _e_bossSelectedEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "bossWearyValueChangeEvent", _e_bossWearyValueChangeEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "boughtTimeChangeEvent", _e_boughtTimeChangeEvent);
            
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectedFloor", _g_get_selectedFloor);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectedBoss", _g_get_selectedBoss);
@@ -561,6 +562,40 @@
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_boughtTimeChangeEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.BossHomeModel gen_to_be_invoked = (Snxxz.UI.BossHomeModel)translator.FastGetCSObj(L, 1);
                System.Action gen_delegate = translator.GetDelegate<System.Action>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action!");
                }
				
                if (gen_param_count == 3)
                {
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.boughtTimeChangeEvent += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.boughtTimeChangeEvent -= gen_delegate;
                        return 0;
                    } 
					
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            LuaAPI.luaL_error(L, "invalid arguments to Snxxz.UI.BossHomeModel.boughtTimeChangeEvent!");
            return 0;
        }
        
        
        
    }

 Lua/Gen/SnxxzUISkillModelWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.SkillModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 35, 25, 15);
            Utils.BeginObjectRegister(type, L, translator, 0, 36, 27, 16);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnInit", _m_UnInit);
@@ -29,6 +29,7 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetQuickBaseSkillArray", _m_GetQuickBaseSkillArray);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetQuickSkillIdByPos", _m_GetQuickSkillIdByPos);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetXpSkillID", _m_GetXpSkillID);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsXpSkill", _m_IsXpSkill);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshSltSkill", _m_RefreshSltSkill);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "AutoUseXp", _m_AutoUseXp);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAutoUseXp", _m_SetAutoUseXp);
@@ -66,6 +67,7 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "jumpToPass", _g_get_jumpToPass);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "minTaskHole", _g_get_minTaskHole);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxTaskHole", _g_get_maxTaskHole);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "skillMatchRedpointable", _g_get_skillMatchRedpointable);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "xpSkill", _g_get_xpSkill);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "presentEquipPage", _g_get_presentEquipPage);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "taskHoleDict", _g_get_taskHoleDict);
@@ -76,6 +78,7 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "passEquipGetWays", _g_get_passEquipGetWays);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "passEquipGetWayTxts", _g_get_passEquipGetWayTxts);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "redpoint", _g_get_redpoint);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "skillMatchRedpoint", _g_get_skillMatchRedpoint);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "presentSltSkillID", _g_get_presentSltSkillID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "skillDraging", _g_get_skillDraging);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "skillDragId", _g_get_skillDragId);
@@ -87,6 +90,7 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "passSkillHoleRedpoints", _g_get_passSkillHoleRedpoints);
            
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "jumpToPass", _s_set_jumpToPass);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "skillMatchRedpointable", _s_set_skillMatchRedpointable);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "equipPassPage", _s_set_equipPassPage);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "UnlockPassHole", _s_set_UnlockPassHole);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "passSkillLimits", _s_set_passSkillLimits);
@@ -307,6 +311,35 @@
                    
                        int gen_ret = gen_to_be_invoked.GetXpSkillID(  );
                        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_IsXpSkill(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.SkillModel gen_to_be_invoked = (Snxxz.UI.SkillModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _skillId = LuaAPI.xlua_tointeger(L, 2);
                    
                        bool gen_ret = gen_to_be_invoked.IsXpSkill( _skillId );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
@@ -1093,6 +1126,20 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_skillMatchRedpointable(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.SkillModel gen_to_be_invoked = (Snxxz.UI.SkillModel)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.skillMatchRedpointable);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_xpSkill(RealStatePtr L)
        {
            try {
@@ -1226,6 +1273,20 @@
            
                Snxxz.UI.SkillModel gen_to_be_invoked = (Snxxz.UI.SkillModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.redpoint);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_skillMatchRedpoint(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.SkillModel gen_to_be_invoked = (Snxxz.UI.SkillModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.skillMatchRedpoint);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
@@ -1376,6 +1437,21 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_skillMatchRedpointable(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.SkillModel gen_to_be_invoked = (Snxxz.UI.SkillModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.skillMatchRedpointable = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_equipPassPage(RealStatePtr L)
        {
            try {

 Lua/Gen/SnxxzUITreasureSkillModelWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.TreasureSkillModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 25, 7, 4);
            Utils.BeginObjectRegister(type, L, translator, 0, 26, 7, 4);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforePlayerDataInitialize", _m_OnBeforePlayerDataInitialize);
@@ -33,6 +33,7 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetPotential", _m_TryGetPotential);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetExpertActiveLevel", _m_TryGetExpertActiveLevel);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTotalExpertSkillLevel", _m_GetTotalExpertSkillLevel);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSatisfyLevelUpMinCostSkillId", _m_GetSatisfyLevelUpMinCostSkillId);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnReceivePackage", _m_OnReceivePackage);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDeleteSkill", _m_OnDeleteSkill);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryLevelUpTreasureSkill", _m_TryLevelUpTreasureSkill);
@@ -406,6 +407,34 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetSatisfyLevelUpMinCostSkillId(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.TreasureSkillModel gen_to_be_invoked = (Snxxz.UI.TreasureSkillModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        int gen_ret = gen_to_be_invoked.GetSatisfyLevelUpMinCostSkillId(  );
                        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_OnReceivePackage(RealStatePtr L)
        {
            try {

 Lua/Gen/WindowJumpMgrWrap.cs.meta

@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 68bc00126159b12408beda121bcbfa5a
timeCreated: 1557818438
timeCreated: 1562147310
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 Lua/Gen/WrapPusher.cs

@@ -34,6 +34,7 @@
                translator.RegisterPushAndGetAndUpdate<UnityEngine.Ray>(translator.PushUnityEngineRay, translator.Get, translator.UpdateUnityEngineRay);
                translator.RegisterPushAndGetAndUpdate<UnityEngine.Bounds>(translator.PushUnityEngineBounds, translator.Get, translator.UpdateUnityEngineBounds);
                translator.RegisterPushAndGetAndUpdate<UnityEngine.Ray2D>(translator.PushUnityEngineRay2D, translator.Get, translator.UpdateUnityEngineRay2D);
                translator.RegisterPushAndGetAndUpdate<JumpUIType>(translator.PushJumpUIType, translator.Get, translator.UpdateJumpUIType);
                translator.RegisterPushAndGetAndUpdate<E_ActorClassType>(translator.PushE_ActorClassType, translator.Get, translator.UpdateE_ActorClassType);
                translator.RegisterPushAndGetAndUpdate<E_ActorState>(translator.PushE_ActorState, translator.Get, translator.UpdateE_ActorState);
                translator.RegisterPushAndGetAndUpdate<E_BuffType>(translator.PushE_BuffType, translator.Get, translator.UpdateE_BuffType);
@@ -624,6 +625,90 @@
                if (!CopyByValue.Pack(buff, 0,  val))
                {
                    throw new Exception("pack fail for UnityEngine.Ray2D ,value="+val);
                }
            }
			
            else
            {
                throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
            }
        }
        
        int JumpUIType_TypeID = -1;
        int JumpUIType_EnumRef = -1;
        
        public void PushJumpUIType(RealStatePtr L, JumpUIType val)
        {
            if (JumpUIType_TypeID == -1)
            {
                bool is_first;
                JumpUIType_TypeID = getTypeId(L, typeof(JumpUIType), out is_first);
				
                if (JumpUIType_EnumRef == -1)
                {
                    Utils.LoadCSTable(L, typeof(JumpUIType));
                    JumpUIType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
                }
				
            }
			
            if (LuaAPI.xlua_tryget_cachedud(L, (int)val, JumpUIType_EnumRef) == 1)
            {
                return;
            }
			
            IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, JumpUIType_TypeID);
            if (!CopyByValue.Pack(buff, 0, (int)val))
            {
                throw new Exception("pack fail fail for JumpUIType ,value="+val);
            }
			
            LuaAPI.lua_getref(L, JumpUIType_EnumRef);
            LuaAPI.lua_pushvalue(L, -2);
            LuaAPI.xlua_rawseti(L, -2, (int)val);
            LuaAPI.lua_pop(L, 1);
			
        }
		
        public void Get(RealStatePtr L, int index, out JumpUIType val)
        {
            LuaTypes type = LuaAPI.lua_type(L, index);
            if (type == LuaTypes.LUA_TUSERDATA )
            {
                if (LuaAPI.xlua_gettypeid(L, index) != JumpUIType_TypeID)
                {
                    throw new Exception("invalid userdata for JumpUIType");
                }
				
                IntPtr buff = LuaAPI.lua_touserdata(L, index);
                int e;
                if (!CopyByValue.UnPack(buff, 0, out e))
                {
                    throw new Exception("unpack fail for JumpUIType");
                }
                val = (JumpUIType)e;
                
            }
            else
            {
                val = (JumpUIType)objectCasters.GetCaster(typeof(JumpUIType))(L, index, null);
            }
        }
		
        public void UpdateJumpUIType(RealStatePtr L, int index, JumpUIType val)
        {
		    
            if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
            {
                if (LuaAPI.xlua_gettypeid(L, index) != JumpUIType_TypeID)
                {
                    throw new Exception("invalid userdata for JumpUIType");
                }
				
                IntPtr buff = LuaAPI.lua_touserdata(L, index);
                if (!CopyByValue.Pack(buff, 0,  (int)val))
                {
                    throw new Exception("pack fail for JumpUIType ,value="+val);
                }
            }
            
@@ -5984,6 +6069,12 @@
                translator.PushUnityEngineRay2D(L, array[index]);
                return true;
            }
            else if (type == typeof(JumpUIType[]))
            {
                JumpUIType[] array = obj as JumpUIType[];
                translator.PushJumpUIType(L, array[index]);
                return true;
            }
            else if (type == typeof(E_ActorClassType[]))
            {
                E_ActorClassType[] array = obj as E_ActorClassType[];
@@ -6416,6 +6507,12 @@
                translator.Get(L, obj_idx, out array[array_idx]);
                return true;
            }
            else if (type == typeof(JumpUIType[]))
            {
                JumpUIType[] array = obj as JumpUIType[];
                translator.Get(L, obj_idx, out array[array_idx]);
                return true;
            }
            else if (type == typeof(E_ActorClassType[]))
            {
                E_ActorClassType[] array = obj as E_ActorClassType[];

 Lua/Gen/XLuaGenAutoRegister.cs

@@ -1579,18 +1579,21 @@
            translator.DelayWrapLoader(typeof(WindowJumpMgr), WindowJumpMgrWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(JumpUIType), JumpUITypeWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.MapModel), SnxxzUIMapModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(WorldMapSkip), WorldMapSkipWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FuncOpen), SnxxzUIFuncOpenWrap.__Register);
        
        }
        
        static void wrapInit10(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FuncOpen), SnxxzUIFuncOpenWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FunctionButton), SnxxzUIFunctionButtonWrap.__Register);
        
@@ -1741,14 +1744,14 @@
        
            translator.DelayWrapLoader(typeof(E_AttackMode), E_AttackModeWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(E_ItemColor), E_ItemColorWrap.__Register);
        
        }
        
        static void wrapInit11(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(E_ItemColor), E_ItemColorWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FindPreciousType), FindPreciousTypeWrap.__Register);
        
        

 Lua/Gen/link.xml

@@ -486,6 +486,7 @@
        <type fullname="Snxxz.UI.OneLevelWin" preserve="all"/>
        <type fullname="Snxxz.UI.WindowCenter" preserve="all"/>
        <type fullname="WindowJumpMgr" preserve="all"/>
        <type fullname="JumpUIType" preserve="all"/>
        <type fullname="Snxxz.UI.MapModel" preserve="all"/>
        <type fullname="WorldMapSkip" preserve="all"/>
        <type fullname="Snxxz.UI.FuncOpen" preserve="all"/>

 System/WindowJump/WindowJumpMgr.cs

@@ -1425,6 +1425,8 @@
/// <summary>

/// 规则是每个系统对应标签页顺序

/// </summary>

/// 
[XLua.LuaCallCSharp]

public enum JumpUIType

{

    None = 0,