JJBB/Assets/Project/Script/GameTables/TableManager.cs

//This code create by CodeEngine ,don't modify

using System;
using System.Collections.Generic;
using System.Collections;
using UnityEngine;
using System.IO;
using Module.Log;
  
namespace GCGame.Table
{

    public class TableManager{

    private static Dictionary<int, Tab_AcaciaTreeBase> g_AcaciaTreeBase;
	
    public static Tab_AcaciaTreeBase GetAcaciaTreeBaseByID(int nKey, int nIndex = 0)
    {
        if(g_AcaciaTreeBase == null)
            InitTable_AcaciaTreeBase();
		Tab_AcaciaTreeBase result;
		g_AcaciaTreeBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_AcaciaTreeBase> GetAcaciaTreeBase()
    {
        if(g_AcaciaTreeBase == null)
            InitTable_AcaciaTreeBase();
        return g_AcaciaTreeBase;
    }
	
    public static bool InitTable_AcaciaTreeBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_AcaciaTreeBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_AcaciaTreeBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_AcaciaTreeBase.Validate(lines[1]))
			{
				g_AcaciaTreeBase = new Dictionary<int, Tab_AcaciaTreeBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_AcaciaTreeBase(line);
						g_AcaciaTreeBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ActInfoClient> g_ActInfoClient;
	
    public static Tab_ActInfoClient GetActInfoClientByID(int nKey, int nIndex = 0)
    {
        if(g_ActInfoClient == null)
            InitTable_ActInfoClient();
		Tab_ActInfoClient result;
		g_ActInfoClient.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ActInfoClient> GetActInfoClient()
    {
        if(g_ActInfoClient == null)
            InitTable_ActInfoClient();
        return g_ActInfoClient;
    }
	
    public static bool InitTable_ActInfoClient()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ActInfoClient.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ActInfoClient.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ActInfoClient.Validate(lines[1]))
			{
				g_ActInfoClient = new Dictionary<int, Tab_ActInfoClient>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ActInfoClient(line);
						g_ActInfoClient[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ActItemUsePath> g_ActItemUsePath;
	
    public static Tab_ActItemUsePath GetActItemUsePathByID(int nKey, int nIndex = 0)
    {
        if(g_ActItemUsePath == null)
            InitTable_ActItemUsePath();
		Tab_ActItemUsePath result;
		g_ActItemUsePath.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ActItemUsePath> GetActItemUsePath()
    {
        if(g_ActItemUsePath == null)
            InitTable_ActItemUsePath();
        return g_ActItemUsePath;
    }
	
    public static bool InitTable_ActItemUsePath()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ActItemUsePath.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ActItemUsePath.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ActItemUsePath.Validate(lines[1]))
			{
				g_ActItemUsePath = new Dictionary<int, Tab_ActItemUsePath>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ActItemUsePath(line);
						g_ActItemUsePath[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ActivityActValLimit> g_ActivityActValLimit;
	
    public static Tab_ActivityActValLimit GetActivityActValLimitByID(int nKey, int nIndex = 0)
    {
        if(g_ActivityActValLimit == null)
            InitTable_ActivityActValLimit();
		Tab_ActivityActValLimit result;
		g_ActivityActValLimit.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ActivityActValLimit> GetActivityActValLimit()
    {
        if(g_ActivityActValLimit == null)
            InitTable_ActivityActValLimit();
        return g_ActivityActValLimit;
    }
	
    public static bool InitTable_ActivityActValLimit()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ActivityActValLimit.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ActivityActValLimit.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ActivityActValLimit.Validate(lines[1]))
			{
				g_ActivityActValLimit = new Dictionary<int, Tab_ActivityActValLimit>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ActivityActValLimit(line);
						g_ActivityActValLimit[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ActivityBase> g_ActivityBase;
	
    public static Tab_ActivityBase GetActivityBaseByID(int nKey, int nIndex = 0)
    {
        if(g_ActivityBase == null)
            InitTable_ActivityBase();
		Tab_ActivityBase result;
		g_ActivityBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ActivityBase> GetActivityBase()
    {
        if(g_ActivityBase == null)
            InitTable_ActivityBase();
        return g_ActivityBase;
    }
	
    public static bool InitTable_ActivityBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ActivityBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ActivityBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ActivityBase.Validate(lines[1]))
			{
				g_ActivityBase = new Dictionary<int, Tab_ActivityBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ActivityBase(line);
						g_ActivityBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ActivityMiser> g_ActivityMiser;
	
    public static Tab_ActivityMiser GetActivityMiserByID(int nKey, int nIndex = 0)
    {
        if(g_ActivityMiser == null)
            InitTable_ActivityMiser();
		Tab_ActivityMiser result;
		g_ActivityMiser.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ActivityMiser> GetActivityMiser()
    {
        if(g_ActivityMiser == null)
            InitTable_ActivityMiser();
        return g_ActivityMiser;
    }
	
    public static bool InitTable_ActivityMiser()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ActivityMiser.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ActivityMiser.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ActivityMiser.Validate(lines[1]))
			{
				g_ActivityMiser = new Dictionary<int, Tab_ActivityMiser>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ActivityMiser(line);
						g_ActivityMiser[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ActivityProfPassLayerOther> g_ActivityProfPassLayerOther;
	
    public static Tab_ActivityProfPassLayerOther GetActivityProfPassLayerOtherByID(int nKey, int nIndex = 0)
    {
        if(g_ActivityProfPassLayerOther == null)
            InitTable_ActivityProfPassLayerOther();
		Tab_ActivityProfPassLayerOther result;
		g_ActivityProfPassLayerOther.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ActivityProfPassLayerOther> GetActivityProfPassLayerOther()
    {
        if(g_ActivityProfPassLayerOther == null)
            InitTable_ActivityProfPassLayerOther();
        return g_ActivityProfPassLayerOther;
    }
	
    public static bool InitTable_ActivityProfPassLayerOther()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ActivityProfPassLayerOther.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ActivityProfPassLayerOther.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ActivityProfPassLayerOther.Validate(lines[1]))
			{
				g_ActivityProfPassLayerOther = new Dictionary<int, Tab_ActivityProfPassLayerOther>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ActivityProfPassLayerOther(line);
						g_ActivityProfPassLayerOther[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ActivityValRew> g_ActivityValRew;
	
    public static Tab_ActivityValRew GetActivityValRewByID(int nKey, int nIndex = 0)
    {
        if(g_ActivityValRew == null)
            InitTable_ActivityValRew();
		Tab_ActivityValRew result;
		g_ActivityValRew.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ActivityValRew> GetActivityValRew()
    {
        if(g_ActivityValRew == null)
            InitTable_ActivityValRew();
        return g_ActivityValRew;
    }
	
    public static bool InitTable_ActivityValRew()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ActivityValRew.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ActivityValRew.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ActivityValRew.Validate(lines[1]))
			{
				g_ActivityValRew = new Dictionary<int, Tab_ActivityValRew>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ActivityValRew(line);
						g_ActivityValRew[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ActValLimit> g_ActValLimit;
	
    public static Tab_ActValLimit GetActValLimitByID(int nKey, int nIndex = 0)
    {
        if(g_ActValLimit == null)
            InitTable_ActValLimit();
		Tab_ActValLimit result;
		g_ActValLimit.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ActValLimit> GetActValLimit()
    {
        if(g_ActValLimit == null)
            InitTable_ActValLimit();
        return g_ActValLimit;
    }
	
    public static bool InitTable_ActValLimit()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ActValLimit.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ActValLimit.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ActValLimit.Validate(lines[1]))
			{
				g_ActValLimit = new Dictionary<int, Tab_ActValLimit>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ActValLimit(line);
						g_ActValLimit[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_AddFellowCarryNum> g_AddFellowCarryNum;
	
    public static Tab_AddFellowCarryNum GetAddFellowCarryNumByID(int nKey, int nIndex = 0)
    {
        if(g_AddFellowCarryNum == null)
            InitTable_AddFellowCarryNum();
		Tab_AddFellowCarryNum result;
		g_AddFellowCarryNum.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_AddFellowCarryNum> GetAddFellowCarryNum()
    {
        if(g_AddFellowCarryNum == null)
            InitTable_AddFellowCarryNum();
        return g_AddFellowCarryNum;
    }
	
    public static bool InitTable_AddFellowCarryNum()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_AddFellowCarryNum.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_AddFellowCarryNum.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_AddFellowCarryNum.Validate(lines[1]))
			{
				g_AddFellowCarryNum = new Dictionary<int, Tab_AddFellowCarryNum>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_AddFellowCarryNum(line);
						g_AddFellowCarryNum[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_AdvanceBase> g_AdvanceBase;
	
    public static Tab_AdvanceBase GetAdvanceBaseByID(int nKey, int nIndex = 0)
    {
        if(g_AdvanceBase == null)
            InitTable_AdvanceBase();
		Tab_AdvanceBase result;
		g_AdvanceBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_AdvanceBase> GetAdvanceBase()
    {
        if(g_AdvanceBase == null)
            InitTable_AdvanceBase();
        return g_AdvanceBase;
    }
	
    public static bool InitTable_AdvanceBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_AdvanceBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_AdvanceBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_AdvanceBase.Validate(lines[1]))
			{
				g_AdvanceBase = new Dictionary<int, Tab_AdvanceBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_AdvanceBase(line);
						g_AdvanceBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_AdvanceEquip> g_AdvanceEquip;
	
    public static Tab_AdvanceEquip GetAdvanceEquipByID(int nKey, int nIndex = 0)
    {
        if(g_AdvanceEquip == null)
            InitTable_AdvanceEquip();
		Tab_AdvanceEquip result;
		g_AdvanceEquip.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_AdvanceEquip> GetAdvanceEquip()
    {
        if(g_AdvanceEquip == null)
            InitTable_AdvanceEquip();
        return g_AdvanceEquip;
    }
	
    public static bool InitTable_AdvanceEquip()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_AdvanceEquip.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_AdvanceEquip.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_AdvanceEquip.Validate(lines[1]))
			{
				g_AdvanceEquip = new Dictionary<int, Tab_AdvanceEquip>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_AdvanceEquip(line);
						g_AdvanceEquip[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_AdvanceFashion> g_AdvanceFashion;
	
    public static Tab_AdvanceFashion GetAdvanceFashionByID(int nKey, int nIndex = 0)
    {
        if(g_AdvanceFashion == null)
            InitTable_AdvanceFashion();
		Tab_AdvanceFashion result;
		g_AdvanceFashion.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_AdvanceFashion> GetAdvanceFashion()
    {
        if(g_AdvanceFashion == null)
            InitTable_AdvanceFashion();
        return g_AdvanceFashion;
    }
	
    public static bool InitTable_AdvanceFashion()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_AdvanceFashion.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_AdvanceFashion.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_AdvanceFashion.Validate(lines[1]))
			{
				g_AdvanceFashion = new Dictionary<int, Tab_AdvanceFashion>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_AdvanceFashion(line);
						g_AdvanceFashion[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_AdvanceOther> g_AdvanceOther;
	
    public static Tab_AdvanceOther GetAdvanceOtherByID(int nKey, int nIndex = 0)
    {
        if(g_AdvanceOther == null)
            InitTable_AdvanceOther();
		Tab_AdvanceOther result;
		g_AdvanceOther.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_AdvanceOther> GetAdvanceOther()
    {
        if(g_AdvanceOther == null)
            InitTable_AdvanceOther();
        return g_AdvanceOther;
    }
	
    public static bool InitTable_AdvanceOther()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_AdvanceOther.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_AdvanceOther.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_AdvanceOther.Validate(lines[1]))
			{
				g_AdvanceOther = new Dictionary<int, Tab_AdvanceOther>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_AdvanceOther(line);
						g_AdvanceOther[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_AdvanceSkill> g_AdvanceSkill;
	
    public static Tab_AdvanceSkill GetAdvanceSkillByID(int nKey, int nIndex = 0)
    {
        if(g_AdvanceSkill == null)
            InitTable_AdvanceSkill();
		Tab_AdvanceSkill result;
		g_AdvanceSkill.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_AdvanceSkill> GetAdvanceSkill()
    {
        if(g_AdvanceSkill == null)
            InitTable_AdvanceSkill();
        return g_AdvanceSkill;
    }
	
    public static bool InitTable_AdvanceSkill()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_AdvanceSkill.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_AdvanceSkill.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_AdvanceSkill.Validate(lines[1]))
			{
				g_AdvanceSkill = new Dictionary<int, Tab_AdvanceSkill>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_AdvanceSkill(line);
						g_AdvanceSkill[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Animation> g_Animation;
	
    public static Tab_Animation GetAnimationByID(int nKey, int nIndex = 0)
    {
        if(g_Animation == null)
            InitTable_Animation();
		Tab_Animation result;
		g_Animation.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Animation> GetAnimation()
    {
        if(g_Animation == null)
            InitTable_Animation();
        return g_Animation;
    }
	
    public static bool InitTable_Animation()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Animation.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Animation.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Animation.Validate(lines[1]))
			{
				g_Animation = new Dictionary<int, Tab_Animation>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Animation(line);
						g_Animation[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_AnimationCurve>> g_AnimationCurve;
	
	public static List<Tab_AnimationCurve> GetAnimationCurveByID(int nKey)
    {
        if(g_AnimationCurve == null)
            InitTable_AnimationCurve();
		List<Tab_AnimationCurve> result;
		g_AnimationCurve.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_AnimationCurve GetAnimationCurveByID(int nKey, int nIndex)
    {
        if(g_AnimationCurve == null)
            InitTable_AnimationCurve();
		List<Tab_AnimationCurve> list;
		Tab_AnimationCurve result = null;
		if (nIndex >= 0 &&
			g_AnimationCurve.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_AnimationCurve>> GetAnimationCurve()
    {
        if(g_AnimationCurve == null)
            InitTable_AnimationCurve();
        return g_AnimationCurve;
    }
	
	public static bool InitTable_AnimationCurve()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_AnimationCurve.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_AnimationCurve.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_AnimationCurve.Validate(lines[1]))
			{
				g_AnimationCurve = new Dictionary<int, List<Tab_AnimationCurve>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_AnimationCurve(line);
						List<Tab_AnimationCurve> list;
						var id = item.GetId();
						if (!g_AnimationCurve.TryGetValue(id, out list))
						{
							list = new List<Tab_AnimationCurve>();
							g_AnimationCurve.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_AuraConfig> g_AuraConfig;
	
    public static Tab_AuraConfig GetAuraConfigByID(int nKey, int nIndex = 0)
    {
        if(g_AuraConfig == null)
            InitTable_AuraConfig();
		Tab_AuraConfig result;
		g_AuraConfig.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_AuraConfig> GetAuraConfig()
    {
        if(g_AuraConfig == null)
            InitTable_AuraConfig();
        return g_AuraConfig;
    }
	
    public static bool InitTable_AuraConfig()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_AuraConfig.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_AuraConfig.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_AuraConfig.Validate(lines[1]))
			{
				g_AuraConfig = new Dictionary<int, Tab_AuraConfig>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_AuraConfig(line);
						g_AuraConfig[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_AutoSearch> g_AutoSearch;
	
    public static Tab_AutoSearch GetAutoSearchByID(int nKey, int nIndex = 0)
    {
        if(g_AutoSearch == null)
            InitTable_AutoSearch();
		Tab_AutoSearch result;
		g_AutoSearch.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_AutoSearch> GetAutoSearch()
    {
        if(g_AutoSearch == null)
            InitTable_AutoSearch();
        return g_AutoSearch;
    }
	
    public static bool InitTable_AutoSearch()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_AutoSearch.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_AutoSearch.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_AutoSearch.Validate(lines[1]))
			{
				g_AutoSearch = new Dictionary<int, Tab_AutoSearch>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_AutoSearch(line);
						g_AutoSearch[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_AutoUseItem> g_AutoUseItem;
	
    public static Tab_AutoUseItem GetAutoUseItemByID(int nKey, int nIndex = 0)
    {
        if(g_AutoUseItem == null)
            InitTable_AutoUseItem();
		Tab_AutoUseItem result;
		g_AutoUseItem.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_AutoUseItem> GetAutoUseItem()
    {
        if(g_AutoUseItem == null)
            InitTable_AutoUseItem();
        return g_AutoUseItem;
    }
	
    public static bool InitTable_AutoUseItem()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_AutoUseItem.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_AutoUseItem.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_AutoUseItem.Validate(lines[1]))
			{
				g_AutoUseItem = new Dictionary<int, Tab_AutoUseItem>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_AutoUseItem(line);
						g_AutoUseItem[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_BackPackUnlock> g_BackPackUnlock;
	
    public static Tab_BackPackUnlock GetBackPackUnlockByID(int nKey, int nIndex = 0)
    {
        if(g_BackPackUnlock == null)
            InitTable_BackPackUnlock();
		Tab_BackPackUnlock result;
		g_BackPackUnlock.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_BackPackUnlock> GetBackPackUnlock()
    {
        if(g_BackPackUnlock == null)
            InitTable_BackPackUnlock();
        return g_BackPackUnlock;
    }
	
    public static bool InitTable_BackPackUnlock()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_BackPackUnlock.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_BackPackUnlock.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_BackPackUnlock.Validate(lines[1]))
			{
				g_BackPackUnlock = new Dictionary<int, Tab_BackPackUnlock>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_BackPackUnlock(line);
						g_BackPackUnlock[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_BloodVeinConfig> g_BloodVeinConfig;
	
    public static Tab_BloodVeinConfig GetBloodVeinConfigByID(int nKey, int nIndex = 0)
    {
        if(g_BloodVeinConfig == null)
            InitTable_BloodVeinConfig();
		Tab_BloodVeinConfig result;
		g_BloodVeinConfig.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_BloodVeinConfig> GetBloodVeinConfig()
    {
        if(g_BloodVeinConfig == null)
            InitTable_BloodVeinConfig();
        return g_BloodVeinConfig;
    }
	
    public static bool InitTable_BloodVeinConfig()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_BloodVeinConfig.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_BloodVeinConfig.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_BloodVeinConfig.Validate(lines[1]))
			{
				g_BloodVeinConfig = new Dictionary<int, Tab_BloodVeinConfig>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_BloodVeinConfig(line);
						g_BloodVeinConfig[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_BloodVeinNode> g_BloodVeinNode;
	
    public static Tab_BloodVeinNode GetBloodVeinNodeByID(int nKey, int nIndex = 0)
    {
        if(g_BloodVeinNode == null)
            InitTable_BloodVeinNode();
		Tab_BloodVeinNode result;
		g_BloodVeinNode.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_BloodVeinNode> GetBloodVeinNode()
    {
        if(g_BloodVeinNode == null)
            InitTable_BloodVeinNode();
        return g_BloodVeinNode;
    }
	
    public static bool InitTable_BloodVeinNode()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_BloodVeinNode.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_BloodVeinNode.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_BloodVeinNode.Validate(lines[1]))
			{
				g_BloodVeinNode = new Dictionary<int, Tab_BloodVeinNode>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_BloodVeinNode(line);
						g_BloodVeinNode[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_BloodVeinNodeBonus> g_BloodVeinNodeBonus;
	
    public static Tab_BloodVeinNodeBonus GetBloodVeinNodeBonusByID(int nKey, int nIndex = 0)
    {
        if(g_BloodVeinNodeBonus == null)
            InitTable_BloodVeinNodeBonus();
		Tab_BloodVeinNodeBonus result;
		g_BloodVeinNodeBonus.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_BloodVeinNodeBonus> GetBloodVeinNodeBonus()
    {
        if(g_BloodVeinNodeBonus == null)
            InitTable_BloodVeinNodeBonus();
        return g_BloodVeinNodeBonus;
    }
	
    public static bool InitTable_BloodVeinNodeBonus()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_BloodVeinNodeBonus.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_BloodVeinNodeBonus.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_BloodVeinNodeBonus.Validate(lines[1]))
			{
				g_BloodVeinNodeBonus = new Dictionary<int, Tab_BloodVeinNodeBonus>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_BloodVeinNodeBonus(line);
						g_BloodVeinNodeBonus[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_BonusForSect>> g_BonusForSect;
	
	public static List<Tab_BonusForSect> GetBonusForSectByID(int nKey)
    {
        if(g_BonusForSect == null)
            InitTable_BonusForSect();
		List<Tab_BonusForSect> result;
		g_BonusForSect.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_BonusForSect GetBonusForSectByID(int nKey, int nIndex)
    {
        if(g_BonusForSect == null)
            InitTable_BonusForSect();
		List<Tab_BonusForSect> list;
		Tab_BonusForSect result = null;
		if (nIndex >= 0 &&
			g_BonusForSect.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_BonusForSect>> GetBonusForSect()
    {
        if(g_BonusForSect == null)
            InitTable_BonusForSect();
        return g_BonusForSect;
    }
	
	public static bool InitTable_BonusForSect()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_BonusForSect.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_BonusForSect.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_BonusForSect.Validate(lines[1]))
			{
				g_BonusForSect = new Dictionary<int, List<Tab_BonusForSect>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_BonusForSect(line);
						List<Tab_BonusForSect> list;
						var id = item.GetId();
						if (!g_BonusForSect.TryGetValue(id, out list))
						{
							list = new List<Tab_BonusForSect>();
							g_BonusForSect.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_BossHandBook> g_BossHandBook;
	
    public static Tab_BossHandBook GetBossHandBookByID(int nKey, int nIndex = 0)
    {
        if(g_BossHandBook == null)
            InitTable_BossHandBook();
		Tab_BossHandBook result;
		g_BossHandBook.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_BossHandBook> GetBossHandBook()
    {
        if(g_BossHandBook == null)
            InitTable_BossHandBook();
        return g_BossHandBook;
    }
	
    public static bool InitTable_BossHandBook()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_BossHandBook.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_BossHandBook.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_BossHandBook.Validate(lines[1]))
			{
				g_BossHandBook = new Dictionary<int, Tab_BossHandBook>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_BossHandBook(line);
						g_BossHandBook[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_BossHandBookCombine> g_BossHandBookCombine;
	
    public static Tab_BossHandBookCombine GetBossHandBookCombineByID(int nKey, int nIndex = 0)
    {
        if(g_BossHandBookCombine == null)
            InitTable_BossHandBookCombine();
		Tab_BossHandBookCombine result;
		g_BossHandBookCombine.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_BossHandBookCombine> GetBossHandBookCombine()
    {
        if(g_BossHandBookCombine == null)
            InitTable_BossHandBookCombine();
        return g_BossHandBookCombine;
    }
	
    public static bool InitTable_BossHandBookCombine()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_BossHandBookCombine.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_BossHandBookCombine.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_BossHandBookCombine.Validate(lines[1]))
			{
				g_BossHandBookCombine = new Dictionary<int, Tab_BossHandBookCombine>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_BossHandBookCombine(line);
						g_BossHandBookCombine[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Bubble> g_Bubble;
	
    public static Tab_Bubble GetBubbleByID(int nKey, int nIndex = 0)
    {
        if(g_Bubble == null)
            InitTable_Bubble();
		Tab_Bubble result;
		g_Bubble.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Bubble> GetBubble()
    {
        if(g_Bubble == null)
            InitTable_Bubble();
        return g_Bubble;
    }
	
    public static bool InitTable_Bubble()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Bubble.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Bubble.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Bubble.Validate(lines[1]))
			{
				g_Bubble = new Dictionary<int, Tab_Bubble>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Bubble(line);
						g_Bubble[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Bullet> g_Bullet;
	
    public static Tab_Bullet GetBulletByID(int nKey, int nIndex = 0)
    {
        if(g_Bullet == null)
            InitTable_Bullet();
		Tab_Bullet result;
		g_Bullet.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Bullet> GetBullet()
    {
        if(g_Bullet == null)
            InitTable_Bullet();
        return g_Bullet;
    }
	
    public static bool InitTable_Bullet()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Bullet.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Bullet.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Bullet.Validate(lines[1]))
			{
				g_Bullet = new Dictionary<int, Tab_Bullet>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Bullet(line);
						g_Bullet[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_BundlePath> g_BundlePath;
	
    public static Tab_BundlePath GetBundlePathByID(int nKey, int nIndex = 0)
    {
        if(g_BundlePath == null)
            InitTable_BundlePath();
		Tab_BundlePath result;
		g_BundlePath.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_BundlePath> GetBundlePath()
    {
        if(g_BundlePath == null)
            InitTable_BundlePath();
        return g_BundlePath;
    }
	
    public static bool InitTable_BundlePath()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_BundlePath.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_BundlePath.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_BundlePath.Validate(lines[1]))
			{
				g_BundlePath = new Dictionary<int, Tab_BundlePath>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_BundlePath(line);
						g_BundlePath[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CameraRock> g_CameraRock;
	
    public static Tab_CameraRock GetCameraRockByID(int nKey, int nIndex = 0)
    {
        if(g_CameraRock == null)
            InitTable_CameraRock();
		Tab_CameraRock result;
		g_CameraRock.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CameraRock> GetCameraRock()
    {
        if(g_CameraRock == null)
            InitTable_CameraRock();
        return g_CameraRock;
    }
	
    public static bool InitTable_CameraRock()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CameraRock.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CameraRock.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CameraRock.Validate(lines[1]))
			{
				g_CameraRock = new Dictionary<int, Tab_CameraRock>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CameraRock(line);
						g_CameraRock[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CangKuUnlock> g_CangKuUnlock;
	
    public static Tab_CangKuUnlock GetCangKuUnlockByID(int nKey, int nIndex = 0)
    {
        if(g_CangKuUnlock == null)
            InitTable_CangKuUnlock();
		Tab_CangKuUnlock result;
		g_CangKuUnlock.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CangKuUnlock> GetCangKuUnlock()
    {
        if(g_CangKuUnlock == null)
            InitTable_CangKuUnlock();
        return g_CangKuUnlock;
    }
	
    public static bool InitTable_CangKuUnlock()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CangKuUnlock.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CangKuUnlock.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CangKuUnlock.Validate(lines[1]))
			{
				g_CangKuUnlock = new Dictionary<int, Tab_CangKuUnlock>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CangKuUnlock(line);
						g_CangKuUnlock[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ChallengeOnceReward> g_ChallengeOnceReward;
	
    public static Tab_ChallengeOnceReward GetChallengeOnceRewardByID(int nKey, int nIndex = 0)
    {
        if(g_ChallengeOnceReward == null)
            InitTable_ChallengeOnceReward();
		Tab_ChallengeOnceReward result;
		g_ChallengeOnceReward.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ChallengeOnceReward> GetChallengeOnceReward()
    {
        if(g_ChallengeOnceReward == null)
            InitTable_ChallengeOnceReward();
        return g_ChallengeOnceReward;
    }
	
    public static bool InitTable_ChallengeOnceReward()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ChallengeOnceReward.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ChallengeOnceReward.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ChallengeOnceReward.Validate(lines[1]))
			{
				g_ChallengeOnceReward = new Dictionary<int, Tab_ChallengeOnceReward>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ChallengeOnceReward(line);
						g_ChallengeOnceReward[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CharModel> g_CharModel;
	
    public static Tab_CharModel GetCharModelByID(int nKey, int nIndex = 0)
    {
        if(g_CharModel == null)
            InitTable_CharModel();
		Tab_CharModel result;
		g_CharModel.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CharModel> GetCharModel()
    {
        if(g_CharModel == null)
            InitTable_CharModel();
        return g_CharModel;
    }
	
    public static bool InitTable_CharModel()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CharModel.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CharModel.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CharModel.Validate(lines[1]))
			{
				g_CharModel = new Dictionary<int, Tab_CharModel>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CharModel(line);
						g_CharModel[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CharMount> g_CharMount;
	
    public static Tab_CharMount GetCharMountByID(int nKey, int nIndex = 0)
    {
        if(g_CharMount == null)
            InitTable_CharMount();
		Tab_CharMount result;
		g_CharMount.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CharMount> GetCharMount()
    {
        if(g_CharMount == null)
            InitTable_CharMount();
        return g_CharMount;
    }
	
    public static bool InitTable_CharMount()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CharMount.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CharMount.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CharMount.Validate(lines[1]))
			{
				g_CharMount = new Dictionary<int, Tab_CharMount>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CharMount(line);
						g_CharMount[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ChatHelper> g_ChatHelper;
	
    public static Tab_ChatHelper GetChatHelperByID(int nKey, int nIndex = 0)
    {
        if(g_ChatHelper == null)
            InitTable_ChatHelper();
		Tab_ChatHelper result;
		g_ChatHelper.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ChatHelper> GetChatHelper()
    {
        if(g_ChatHelper == null)
            InitTable_ChatHelper();
        return g_ChatHelper;
    }
	
    public static bool InitTable_ChatHelper()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ChatHelper.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ChatHelper.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ChatHelper.Validate(lines[1]))
			{
				g_ChatHelper = new Dictionary<int, Tab_ChatHelper>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ChatHelper(line);
						g_ChatHelper[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ChatHelperHot> g_ChatHelperHot;
	
    public static Tab_ChatHelperHot GetChatHelperHotByID(int nKey, int nIndex = 0)
    {
        if(g_ChatHelperHot == null)
            InitTable_ChatHelperHot();
		Tab_ChatHelperHot result;
		g_ChatHelperHot.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ChatHelperHot> GetChatHelperHot()
    {
        if(g_ChatHelperHot == null)
            InitTable_ChatHelperHot();
        return g_ChatHelperHot;
    }
	
    public static bool InitTable_ChatHelperHot()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ChatHelperHot.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ChatHelperHot.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ChatHelperHot.Validate(lines[1]))
			{
				g_ChatHelperHot = new Dictionary<int, Tab_ChatHelperHot>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ChatHelperHot(line);
						g_ChatHelperHot[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ChatLimit> g_ChatLimit;
	
    public static Tab_ChatLimit GetChatLimitByID(int nKey, int nIndex = 0)
    {
        if(g_ChatLimit == null)
            InitTable_ChatLimit();
		Tab_ChatLimit result;
		g_ChatLimit.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ChatLimit> GetChatLimit()
    {
        if(g_ChatLimit == null)
            InitTable_ChatLimit();
        return g_ChatLimit;
    }
	
    public static bool InitTable_ChatLimit()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ChatLimit.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ChatLimit.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ChatLimit.Validate(lines[1]))
			{
				g_ChatLimit = new Dictionary<int, Tab_ChatLimit>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ChatLimit(line);
						g_ChatLimit[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ChildrenAdventure> g_ChildrenAdventure;
	
    public static Tab_ChildrenAdventure GetChildrenAdventureByID(int nKey, int nIndex = 0)
    {
        if(g_ChildrenAdventure == null)
            InitTable_ChildrenAdventure();
		Tab_ChildrenAdventure result;
		g_ChildrenAdventure.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ChildrenAdventure> GetChildrenAdventure()
    {
        if(g_ChildrenAdventure == null)
            InitTable_ChildrenAdventure();
        return g_ChildrenAdventure;
    }
	
    public static bool InitTable_ChildrenAdventure()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ChildrenAdventure.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ChildrenAdventure.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ChildrenAdventure.Validate(lines[1]))
			{
				g_ChildrenAdventure = new Dictionary<int, Tab_ChildrenAdventure>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ChildrenAdventure(line);
						g_ChildrenAdventure[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ChildrenFashion> g_ChildrenFashion;
	
    public static Tab_ChildrenFashion GetChildrenFashionByID(int nKey, int nIndex = 0)
    {
        if(g_ChildrenFashion == null)
            InitTable_ChildrenFashion();
		Tab_ChildrenFashion result;
		g_ChildrenFashion.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ChildrenFashion> GetChildrenFashion()
    {
        if(g_ChildrenFashion == null)
            InitTable_ChildrenFashion();
        return g_ChildrenFashion;
    }
	
    public static bool InitTable_ChildrenFashion()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ChildrenFashion.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ChildrenFashion.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ChildrenFashion.Validate(lines[1]))
			{
				g_ChildrenFashion = new Dictionary<int, Tab_ChildrenFashion>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ChildrenFashion(line);
						g_ChildrenFashion[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ChildrenInitialCombatAttr> g_ChildrenInitialCombatAttr;
	
    public static Tab_ChildrenInitialCombatAttr GetChildrenInitialCombatAttrByID(int nKey, int nIndex = 0)
    {
        if(g_ChildrenInitialCombatAttr == null)
            InitTable_ChildrenInitialCombatAttr();
		Tab_ChildrenInitialCombatAttr result;
		g_ChildrenInitialCombatAttr.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ChildrenInitialCombatAttr> GetChildrenInitialCombatAttr()
    {
        if(g_ChildrenInitialCombatAttr == null)
            InitTable_ChildrenInitialCombatAttr();
        return g_ChildrenInitialCombatAttr;
    }
	
    public static bool InitTable_ChildrenInitialCombatAttr()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ChildrenInitialCombatAttr.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ChildrenInitialCombatAttr.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ChildrenInitialCombatAttr.Validate(lines[1]))
			{
				g_ChildrenInitialCombatAttr = new Dictionary<int, Tab_ChildrenInitialCombatAttr>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ChildrenInitialCombatAttr(line);
						g_ChildrenInitialCombatAttr[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ChildrenLevelUp> g_ChildrenLevelUp;
	
    public static Tab_ChildrenLevelUp GetChildrenLevelUpByID(int nKey, int nIndex = 0)
    {
        if(g_ChildrenLevelUp == null)
            InitTable_ChildrenLevelUp();
		Tab_ChildrenLevelUp result;
		g_ChildrenLevelUp.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ChildrenLevelUp> GetChildrenLevelUp()
    {
        if(g_ChildrenLevelUp == null)
            InitTable_ChildrenLevelUp();
        return g_ChildrenLevelUp;
    }
	
    public static bool InitTable_ChildrenLevelUp()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ChildrenLevelUp.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ChildrenLevelUp.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ChildrenLevelUp.Validate(lines[1]))
			{
				g_ChildrenLevelUp = new Dictionary<int, Tab_ChildrenLevelUp>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ChildrenLevelUp(line);
						g_ChildrenLevelUp[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ChildrenPara> g_ChildrenPara;
	
    public static Tab_ChildrenPara GetChildrenParaByID(int nKey, int nIndex = 0)
    {
        if(g_ChildrenPara == null)
            InitTable_ChildrenPara();
		Tab_ChildrenPara result;
		g_ChildrenPara.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ChildrenPara> GetChildrenPara()
    {
        if(g_ChildrenPara == null)
            InitTable_ChildrenPara();
        return g_ChildrenPara;
    }
	
    public static bool InitTable_ChildrenPara()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ChildrenPara.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ChildrenPara.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ChildrenPara.Validate(lines[1]))
			{
				g_ChildrenPara = new Dictionary<int, Tab_ChildrenPara>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ChildrenPara(line);
						g_ChildrenPara[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ChildrenSkillParam> g_ChildrenSkillParam;
	
    public static Tab_ChildrenSkillParam GetChildrenSkillParamByID(int nKey, int nIndex = 0)
    {
        if(g_ChildrenSkillParam == null)
            InitTable_ChildrenSkillParam();
		Tab_ChildrenSkillParam result;
		g_ChildrenSkillParam.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ChildrenSkillParam> GetChildrenSkillParam()
    {
        if(g_ChildrenSkillParam == null)
            InitTable_ChildrenSkillParam();
        return g_ChildrenSkillParam;
    }
	
    public static bool InitTable_ChildrenSkillParam()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ChildrenSkillParam.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ChildrenSkillParam.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ChildrenSkillParam.Validate(lines[1]))
			{
				g_ChildrenSkillParam = new Dictionary<int, Tab_ChildrenSkillParam>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ChildrenSkillParam(line);
						g_ChildrenSkillParam[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ChildrenStateType> g_ChildrenStateType;
	
    public static Tab_ChildrenStateType GetChildrenStateTypeByID(int nKey, int nIndex = 0)
    {
        if(g_ChildrenStateType == null)
            InitTable_ChildrenStateType();
		Tab_ChildrenStateType result;
		g_ChildrenStateType.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ChildrenStateType> GetChildrenStateType()
    {
        if(g_ChildrenStateType == null)
            InitTable_ChildrenStateType();
        return g_ChildrenStateType;
    }
	
    public static bool InitTable_ChildrenStateType()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ChildrenStateType.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ChildrenStateType.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ChildrenStateType.Validate(lines[1]))
			{
				g_ChildrenStateType = new Dictionary<int, Tab_ChildrenStateType>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ChildrenStateType(line);
						g_ChildrenStateType[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ChildrenStudyLevelUp> g_ChildrenStudyLevelUp;
	
    public static Tab_ChildrenStudyLevelUp GetChildrenStudyLevelUpByID(int nKey, int nIndex = 0)
    {
        if(g_ChildrenStudyLevelUp == null)
            InitTable_ChildrenStudyLevelUp();
		Tab_ChildrenStudyLevelUp result;
		g_ChildrenStudyLevelUp.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ChildrenStudyLevelUp> GetChildrenStudyLevelUp()
    {
        if(g_ChildrenStudyLevelUp == null)
            InitTable_ChildrenStudyLevelUp();
        return g_ChildrenStudyLevelUp;
    }
	
    public static bool InitTable_ChildrenStudyLevelUp()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ChildrenStudyLevelUp.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ChildrenStudyLevelUp.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ChildrenStudyLevelUp.Validate(lines[1]))
			{
				g_ChildrenStudyLevelUp = new Dictionary<int, Tab_ChildrenStudyLevelUp>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ChildrenStudyLevelUp(line);
						g_ChildrenStudyLevelUp[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CircleTaskGameRewardMulti> g_CircleTaskGameRewardMulti;
	
    public static Tab_CircleTaskGameRewardMulti GetCircleTaskGameRewardMultiByID(int nKey, int nIndex = 0)
    {
        if(g_CircleTaskGameRewardMulti == null)
            InitTable_CircleTaskGameRewardMulti();
		Tab_CircleTaskGameRewardMulti result;
		g_CircleTaskGameRewardMulti.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CircleTaskGameRewardMulti> GetCircleTaskGameRewardMulti()
    {
        if(g_CircleTaskGameRewardMulti == null)
            InitTable_CircleTaskGameRewardMulti();
        return g_CircleTaskGameRewardMulti;
    }
	
    public static bool InitTable_CircleTaskGameRewardMulti()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CircleTaskGameRewardMulti.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CircleTaskGameRewardMulti.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CircleTaskGameRewardMulti.Validate(lines[1]))
			{
				g_CircleTaskGameRewardMulti = new Dictionary<int, Tab_CircleTaskGameRewardMulti>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CircleTaskGameRewardMulti(line);
						g_CircleTaskGameRewardMulti[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CircleTaskGameRewards> g_CircleTaskGameRewards;
	
    public static Tab_CircleTaskGameRewards GetCircleTaskGameRewardsByID(int nKey, int nIndex = 0)
    {
        if(g_CircleTaskGameRewards == null)
            InitTable_CircleTaskGameRewards();
		Tab_CircleTaskGameRewards result;
		g_CircleTaskGameRewards.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CircleTaskGameRewards> GetCircleTaskGameRewards()
    {
        if(g_CircleTaskGameRewards == null)
            InitTable_CircleTaskGameRewards();
        return g_CircleTaskGameRewards;
    }
	
    public static bool InitTable_CircleTaskGameRewards()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CircleTaskGameRewards.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CircleTaskGameRewards.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CircleTaskGameRewards.Validate(lines[1]))
			{
				g_CircleTaskGameRewards = new Dictionary<int, Tab_CircleTaskGameRewards>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CircleTaskGameRewards(line);
						g_CircleTaskGameRewards[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ClientNPC> g_ClientNPC;
	
    public static Tab_ClientNPC GetClientNPCByID(int nKey, int nIndex = 0)
    {
        if(g_ClientNPC == null)
            InitTable_ClientNPC();
		Tab_ClientNPC result;
		g_ClientNPC.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ClientNPC> GetClientNPC()
    {
        if(g_ClientNPC == null)
            InitTable_ClientNPC();
        return g_ClientNPC;
    }
	
    public static bool InitTable_ClientNPC()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ClientNPC.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ClientNPC.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ClientNPC.Validate(lines[1]))
			{
				g_ClientNPC = new Dictionary<int, Tab_ClientNPC>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ClientNPC(line);
						g_ClientNPC[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_ClientPath>> g_ClientPath;
	
	public static List<Tab_ClientPath> GetClientPathByID(int nKey)
    {
        if(g_ClientPath == null)
            InitTable_ClientPath();
		List<Tab_ClientPath> result;
		g_ClientPath.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_ClientPath GetClientPathByID(int nKey, int nIndex)
    {
        if(g_ClientPath == null)
            InitTable_ClientPath();
		List<Tab_ClientPath> list;
		Tab_ClientPath result = null;
		if (nIndex >= 0 &&
			g_ClientPath.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_ClientPath>> GetClientPath()
    {
        if(g_ClientPath == null)
            InitTable_ClientPath();
        return g_ClientPath;
    }
	
	public static bool InitTable_ClientPath()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ClientPath.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ClientPath.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ClientPath.Validate(lines[1]))
			{
				g_ClientPath = new Dictionary<int, List<Tab_ClientPath>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ClientPath(line);
						List<Tab_ClientPath> list;
						var id = item.GetId();
						if (!g_ClientPath.TryGetValue(id, out list))
						{
							list = new List<Tab_ClientPath>();
							g_ClientPath.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_ClientPathMover>> g_ClientPathMover;
	
	public static List<Tab_ClientPathMover> GetClientPathMoverByID(int nKey)
    {
        if(g_ClientPathMover == null)
            InitTable_ClientPathMover();
		List<Tab_ClientPathMover> result;
		g_ClientPathMover.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_ClientPathMover GetClientPathMoverByID(int nKey, int nIndex)
    {
        if(g_ClientPathMover == null)
            InitTable_ClientPathMover();
		List<Tab_ClientPathMover> list;
		Tab_ClientPathMover result = null;
		if (nIndex >= 0 &&
			g_ClientPathMover.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_ClientPathMover>> GetClientPathMover()
    {
        if(g_ClientPathMover == null)
            InitTable_ClientPathMover();
        return g_ClientPathMover;
    }
	
	public static bool InitTable_ClientPathMover()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ClientPathMover.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ClientPathMover.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ClientPathMover.Validate(lines[1]))
			{
				g_ClientPathMover = new Dictionary<int, List<Tab_ClientPathMover>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ClientPathMover(line);
						List<Tab_ClientPathMover> list;
						var id = item.GetId();
						if (!g_ClientPathMover.TryGetValue(id, out list))
						{
							list = new List<Tab_ClientPathMover>();
							g_ClientPathMover.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_CollectItem>> g_CollectItem;
	
	public static List<Tab_CollectItem> GetCollectItemByID(int nKey)
    {
        if(g_CollectItem == null)
            InitTable_CollectItem();
		List<Tab_CollectItem> result;
		g_CollectItem.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_CollectItem GetCollectItemByID(int nKey, int nIndex)
    {
        if(g_CollectItem == null)
            InitTable_CollectItem();
		List<Tab_CollectItem> list;
		Tab_CollectItem result = null;
		if (nIndex >= 0 &&
			g_CollectItem.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_CollectItem>> GetCollectItem()
    {
        if(g_CollectItem == null)
            InitTable_CollectItem();
        return g_CollectItem;
    }
	
	public static bool InitTable_CollectItem()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CollectItem.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CollectItem.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CollectItem.Validate(lines[1]))
			{
				g_CollectItem = new Dictionary<int, List<Tab_CollectItem>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CollectItem(line);
						List<Tab_CollectItem> list;
						var id = item.GetId();
						if (!g_CollectItem.TryGetValue(id, out list))
						{
							list = new List<Tab_CollectItem>();
							g_CollectItem.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CombatMagicWeaponSuit> g_CombatMagicWeaponSuit;
	
    public static Tab_CombatMagicWeaponSuit GetCombatMagicWeaponSuitByID(int nKey, int nIndex = 0)
    {
        if(g_CombatMagicWeaponSuit == null)
            InitTable_CombatMagicWeaponSuit();
		Tab_CombatMagicWeaponSuit result;
		g_CombatMagicWeaponSuit.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CombatMagicWeaponSuit> GetCombatMagicWeaponSuit()
    {
        if(g_CombatMagicWeaponSuit == null)
            InitTable_CombatMagicWeaponSuit();
        return g_CombatMagicWeaponSuit;
    }
	
    public static bool InitTable_CombatMagicWeaponSuit()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CombatMagicWeaponSuit.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CombatMagicWeaponSuit.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CombatMagicWeaponSuit.Validate(lines[1]))
			{
				g_CombatMagicWeaponSuit = new Dictionary<int, Tab_CombatMagicWeaponSuit>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CombatMagicWeaponSuit(line);
						g_CombatMagicWeaponSuit[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CombatOther> g_CombatOther;
	
    public static Tab_CombatOther GetCombatOtherByID(int nKey, int nIndex = 0)
    {
        if(g_CombatOther == null)
            InitTable_CombatOther();
		Tab_CombatOther result;
		g_CombatOther.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CombatOther> GetCombatOther()
    {
        if(g_CombatOther == null)
            InitTable_CombatOther();
        return g_CombatOther;
    }
	
    public static bool InitTable_CombatOther()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CombatOther.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CombatOther.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CombatOther.Validate(lines[1]))
			{
				g_CombatOther = new Dictionary<int, Tab_CombatOther>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CombatOther(line);
						g_CombatOther[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CombatPropParam> g_CombatPropParam;
	
    public static Tab_CombatPropParam GetCombatPropParamByID(int nKey, int nIndex = 0)
    {
        if(g_CombatPropParam == null)
            InitTable_CombatPropParam();
		Tab_CombatPropParam result;
		g_CombatPropParam.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CombatPropParam> GetCombatPropParam()
    {
        if(g_CombatPropParam == null)
            InitTable_CombatPropParam();
        return g_CombatPropParam;
    }
	
    public static bool InitTable_CombatPropParam()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CombatPropParam.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CombatPropParam.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CombatPropParam.Validate(lines[1]))
			{
				g_CombatPropParam = new Dictionary<int, Tab_CombatPropParam>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CombatPropParam(line);
						g_CombatPropParam[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CombatTip> g_CombatTip;
	
    public static Tab_CombatTip GetCombatTipByID(int nKey, int nIndex = 0)
    {
        if(g_CombatTip == null)
            InitTable_CombatTip();
		Tab_CombatTip result;
		g_CombatTip.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CombatTip> GetCombatTip()
    {
        if(g_CombatTip == null)
            InitTable_CombatTip();
        return g_CombatTip;
    }
	
    public static bool InitTable_CombatTip()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CombatTip.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CombatTip.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CombatTip.Validate(lines[1]))
			{
				g_CombatTip = new Dictionary<int, Tab_CombatTip>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CombatTip(line);
						g_CombatTip[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CommonFashionItem> g_CommonFashionItem;
	
    public static Tab_CommonFashionItem GetCommonFashionItemByID(int nKey, int nIndex = 0)
    {
        if(g_CommonFashionItem == null)
            InitTable_CommonFashionItem();
		Tab_CommonFashionItem result;
		g_CommonFashionItem.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CommonFashionItem> GetCommonFashionItem()
    {
        if(g_CommonFashionItem == null)
            InitTable_CommonFashionItem();
        return g_CommonFashionItem;
    }
	
    public static bool InitTable_CommonFashionItem()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CommonFashionItem.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CommonFashionItem.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CommonFashionItem.Validate(lines[1]))
			{
				g_CommonFashionItem = new Dictionary<int, Tab_CommonFashionItem>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CommonFashionItem(line);
						g_CommonFashionItem[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CommonItem> g_CommonItem;
	
    public static Tab_CommonItem GetCommonItemByID(int nKey, int nIndex = 0)
    {
        if(g_CommonItem == null)
            InitTable_CommonItem();
		Tab_CommonItem result;
		g_CommonItem.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CommonItem> GetCommonItem()
    {
        if(g_CommonItem == null)
            InitTable_CommonItem();
        return g_CommonItem;
    }
	
    public static bool InitTable_CommonItem()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CommonItem.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CommonItem.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CommonItem.Validate(lines[1]))
			{
				g_CommonItem = new Dictionary<int, Tab_CommonItem>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CommonItem(line);
						g_CommonItem[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CommonSportsSet> g_CommonSportsSet;
	
    public static Tab_CommonSportsSet GetCommonSportsSetByID(int nKey, int nIndex = 0)
    {
        if(g_CommonSportsSet == null)
            InitTable_CommonSportsSet();
		Tab_CommonSportsSet result;
		g_CommonSportsSet.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CommonSportsSet> GetCommonSportsSet()
    {
        if(g_CommonSportsSet == null)
            InitTable_CommonSportsSet();
        return g_CommonSportsSet;
    }
	
    public static bool InitTable_CommonSportsSet()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CommonSportsSet.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CommonSportsSet.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CommonSportsSet.Validate(lines[1]))
			{
				g_CommonSportsSet = new Dictionary<int, Tab_CommonSportsSet>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CommonSportsSet(line);
						g_CommonSportsSet[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Consum> g_Consum;
	
    public static Tab_Consum GetConsumByID(int nKey, int nIndex = 0)
    {
        if(g_Consum == null)
            InitTable_Consum();
		Tab_Consum result;
		g_Consum.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Consum> GetConsum()
    {
        if(g_Consum == null)
            InitTable_Consum();
        return g_Consum;
    }
	
    public static bool InitTable_Consum()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Consum.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Consum.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Consum.Validate(lines[1]))
			{
				g_Consum = new Dictionary<int, Tab_Consum>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Consum(line);
						g_Consum[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CoolDownTime> g_CoolDownTime;
	
    public static Tab_CoolDownTime GetCoolDownTimeByID(int nKey, int nIndex = 0)
    {
        if(g_CoolDownTime == null)
            InitTable_CoolDownTime();
		Tab_CoolDownTime result;
		g_CoolDownTime.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CoolDownTime> GetCoolDownTime()
    {
        if(g_CoolDownTime == null)
            InitTable_CoolDownTime();
        return g_CoolDownTime;
    }
	
    public static bool InitTable_CoolDownTime()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CoolDownTime.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CoolDownTime.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CoolDownTime.Validate(lines[1]))
			{
				g_CoolDownTime = new Dictionary<int, Tab_CoolDownTime>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CoolDownTime(line);
						g_CoolDownTime[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CopyBuff> g_CopyBuff;
	
    public static Tab_CopyBuff GetCopyBuffByID(int nKey, int nIndex = 0)
    {
        if(g_CopyBuff == null)
            InitTable_CopyBuff();
		Tab_CopyBuff result;
		g_CopyBuff.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CopyBuff> GetCopyBuff()
    {
        if(g_CopyBuff == null)
            InitTable_CopyBuff();
        return g_CopyBuff;
    }
	
    public static bool InitTable_CopyBuff()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CopyBuff.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CopyBuff.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CopyBuff.Validate(lines[1]))
			{
				g_CopyBuff = new Dictionary<int, Tab_CopyBuff>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CopyBuff(line);
						g_CopyBuff[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CopySceneReward> g_CopySceneReward;
	
    public static Tab_CopySceneReward GetCopySceneRewardByID(int nKey, int nIndex = 0)
    {
        if(g_CopySceneReward == null)
            InitTable_CopySceneReward();
		Tab_CopySceneReward result;
		g_CopySceneReward.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CopySceneReward> GetCopySceneReward()
    {
        if(g_CopySceneReward == null)
            InitTable_CopySceneReward();
        return g_CopySceneReward;
    }
	
    public static bool InitTable_CopySceneReward()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CopySceneReward.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CopySceneReward.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CopySceneReward.Validate(lines[1]))
			{
				g_CopySceneReward = new Dictionary<int, Tab_CopySceneReward>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CopySceneReward(line);
						g_CopySceneReward[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_CountLimit>> g_CountLimit;
	
	public static List<Tab_CountLimit> GetCountLimitByID(int nKey)
    {
        if(g_CountLimit == null)
            InitTable_CountLimit();
		List<Tab_CountLimit> result;
		g_CountLimit.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_CountLimit GetCountLimitByID(int nKey, int nIndex)
    {
        if(g_CountLimit == null)
            InitTable_CountLimit();
		List<Tab_CountLimit> list;
		Tab_CountLimit result = null;
		if (nIndex >= 0 &&
			g_CountLimit.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_CountLimit>> GetCountLimit()
    {
        if(g_CountLimit == null)
            InitTable_CountLimit();
        return g_CountLimit;
    }
	
	public static bool InitTable_CountLimit()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CountLimit.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CountLimit.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CountLimit.Validate(lines[1]))
			{
				g_CountLimit = new Dictionary<int, List<Tab_CountLimit>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CountLimit(line);
						List<Tab_CountLimit> list;
						var id = item.GetId();
						if (!g_CountLimit.TryGetValue(id, out list))
						{
							list = new List<Tab_CountLimit>();
							g_CountLimit.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CrossSerEscortAward> g_CrossSerEscortAward;
	
    public static Tab_CrossSerEscortAward GetCrossSerEscortAwardByID(int nKey, int nIndex = 0)
    {
        if(g_CrossSerEscortAward == null)
            InitTable_CrossSerEscortAward();
		Tab_CrossSerEscortAward result;
		g_CrossSerEscortAward.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CrossSerEscortAward> GetCrossSerEscortAward()
    {
        if(g_CrossSerEscortAward == null)
            InitTable_CrossSerEscortAward();
        return g_CrossSerEscortAward;
    }
	
    public static bool InitTable_CrossSerEscortAward()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CrossSerEscortAward.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CrossSerEscortAward.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CrossSerEscortAward.Validate(lines[1]))
			{
				g_CrossSerEscortAward = new Dictionary<int, Tab_CrossSerEscortAward>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CrossSerEscortAward(line);
						g_CrossSerEscortAward[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CrossSerEscortConfig> g_CrossSerEscortConfig;
	
    public static Tab_CrossSerEscortConfig GetCrossSerEscortConfigByID(int nKey, int nIndex = 0)
    {
        if(g_CrossSerEscortConfig == null)
            InitTable_CrossSerEscortConfig();
		Tab_CrossSerEscortConfig result;
		g_CrossSerEscortConfig.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CrossSerEscortConfig> GetCrossSerEscortConfig()
    {
        if(g_CrossSerEscortConfig == null)
            InitTable_CrossSerEscortConfig();
        return g_CrossSerEscortConfig;
    }
	
    public static bool InitTable_CrossSerEscortConfig()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CrossSerEscortConfig.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CrossSerEscortConfig.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CrossSerEscortConfig.Validate(lines[1]))
			{
				g_CrossSerEscortConfig = new Dictionary<int, Tab_CrossSerEscortConfig>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CrossSerEscortConfig(line);
						g_CrossSerEscortConfig[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CrossSerFlagAward> g_CrossSerFlagAward;
	
    public static Tab_CrossSerFlagAward GetCrossSerFlagAwardByID(int nKey, int nIndex = 0)
    {
        if(g_CrossSerFlagAward == null)
            InitTable_CrossSerFlagAward();
		Tab_CrossSerFlagAward result;
		g_CrossSerFlagAward.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CrossSerFlagAward> GetCrossSerFlagAward()
    {
        if(g_CrossSerFlagAward == null)
            InitTable_CrossSerFlagAward();
        return g_CrossSerFlagAward;
    }
	
    public static bool InitTable_CrossSerFlagAward()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CrossSerFlagAward.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CrossSerFlagAward.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CrossSerFlagAward.Validate(lines[1]))
			{
				g_CrossSerFlagAward = new Dictionary<int, Tab_CrossSerFlagAward>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CrossSerFlagAward(line);
						g_CrossSerFlagAward[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CrossSerFlagConfig> g_CrossSerFlagConfig;
	
    public static Tab_CrossSerFlagConfig GetCrossSerFlagConfigByID(int nKey, int nIndex = 0)
    {
        if(g_CrossSerFlagConfig == null)
            InitTable_CrossSerFlagConfig();
		Tab_CrossSerFlagConfig result;
		g_CrossSerFlagConfig.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CrossSerFlagConfig> GetCrossSerFlagConfig()
    {
        if(g_CrossSerFlagConfig == null)
            InitTable_CrossSerFlagConfig();
        return g_CrossSerFlagConfig;
    }
	
    public static bool InitTable_CrossSerFlagConfig()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CrossSerFlagConfig.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CrossSerFlagConfig.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CrossSerFlagConfig.Validate(lines[1]))
			{
				g_CrossSerFlagConfig = new Dictionary<int, Tab_CrossSerFlagConfig>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CrossSerFlagConfig(line);
						g_CrossSerFlagConfig[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CrossSerFlagPoint> g_CrossSerFlagPoint;
	
    public static Tab_CrossSerFlagPoint GetCrossSerFlagPointByID(int nKey, int nIndex = 0)
    {
        if(g_CrossSerFlagPoint == null)
            InitTable_CrossSerFlagPoint();
		Tab_CrossSerFlagPoint result;
		g_CrossSerFlagPoint.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CrossSerFlagPoint> GetCrossSerFlagPoint()
    {
        if(g_CrossSerFlagPoint == null)
            InitTable_CrossSerFlagPoint();
        return g_CrossSerFlagPoint;
    }
	
    public static bool InitTable_CrossSerFlagPoint()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CrossSerFlagPoint.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CrossSerFlagPoint.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CrossSerFlagPoint.Validate(lines[1]))
			{
				g_CrossSerFlagPoint = new Dictionary<int, Tab_CrossSerFlagPoint>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CrossSerFlagPoint(line);
						g_CrossSerFlagPoint[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_CurrencyExchange> g_CurrencyExchange;
	
    public static Tab_CurrencyExchange GetCurrencyExchangeByID(int nKey, int nIndex = 0)
    {
        if(g_CurrencyExchange == null)
            InitTable_CurrencyExchange();
		Tab_CurrencyExchange result;
		g_CurrencyExchange.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_CurrencyExchange> GetCurrencyExchange()
    {
        if(g_CurrencyExchange == null)
            InitTable_CurrencyExchange();
        return g_CurrencyExchange;
    }
	
    public static bool InitTable_CurrencyExchange()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_CurrencyExchange.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_CurrencyExchange.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_CurrencyExchange.Validate(lines[1]))
			{
				g_CurrencyExchange = new Dictionary<int, Tab_CurrencyExchange>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_CurrencyExchange(line);
						g_CurrencyExchange[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_DailyCopy> g_DailyCopy;
	
    public static Tab_DailyCopy GetDailyCopyByID(int nKey, int nIndex = 0)
    {
        if(g_DailyCopy == null)
            InitTable_DailyCopy();
		Tab_DailyCopy result;
		g_DailyCopy.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_DailyCopy> GetDailyCopy()
    {
        if(g_DailyCopy == null)
            InitTable_DailyCopy();
        return g_DailyCopy;
    }
	
    public static bool InitTable_DailyCopy()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_DailyCopy.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_DailyCopy.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_DailyCopy.Validate(lines[1]))
			{
				g_DailyCopy = new Dictionary<int, Tab_DailyCopy>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_DailyCopy(line);
						g_DailyCopy[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_DailyCopyBuy> g_DailyCopyBuy;
	
    public static Tab_DailyCopyBuy GetDailyCopyBuyByID(int nKey, int nIndex = 0)
    {
        if(g_DailyCopyBuy == null)
            InitTable_DailyCopyBuy();
		Tab_DailyCopyBuy result;
		g_DailyCopyBuy.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_DailyCopyBuy> GetDailyCopyBuy()
    {
        if(g_DailyCopyBuy == null)
            InitTable_DailyCopyBuy();
        return g_DailyCopyBuy;
    }
	
    public static bool InitTable_DailyCopyBuy()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_DailyCopyBuy.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_DailyCopyBuy.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_DailyCopyBuy.Validate(lines[1]))
			{
				g_DailyCopyBuy = new Dictionary<int, Tab_DailyCopyBuy>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_DailyCopyBuy(line);
						g_DailyCopyBuy[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_DamageBoardType> g_DamageBoardType;
	
    public static Tab_DamageBoardType GetDamageBoardTypeByID(int nKey, int nIndex = 0)
    {
        if(g_DamageBoardType == null)
            InitTable_DamageBoardType();
		Tab_DamageBoardType result;
		g_DamageBoardType.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_DamageBoardType> GetDamageBoardType()
    {
        if(g_DamageBoardType == null)
            InitTable_DamageBoardType();
        return g_DamageBoardType;
    }
	
    public static bool InitTable_DamageBoardType()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_DamageBoardType.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_DamageBoardType.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_DamageBoardType.Validate(lines[1]))
			{
				g_DamageBoardType = new Dictionary<int, Tab_DamageBoardType>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_DamageBoardType(line);
						g_DamageBoardType[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_DropLuckAddon> g_DropLuckAddon;
	
    public static Tab_DropLuckAddon GetDropLuckAddonByID(int nKey, int nIndex = 0)
    {
        if(g_DropLuckAddon == null)
            InitTable_DropLuckAddon();
		Tab_DropLuckAddon result;
		g_DropLuckAddon.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_DropLuckAddon> GetDropLuckAddon()
    {
        if(g_DropLuckAddon == null)
            InitTable_DropLuckAddon();
        return g_DropLuckAddon;
    }
	
    public static bool InitTable_DropLuckAddon()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_DropLuckAddon.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_DropLuckAddon.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_DropLuckAddon.Validate(lines[1]))
			{
				g_DropLuckAddon = new Dictionary<int, Tab_DropLuckAddon>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_DropLuckAddon(line);
						g_DropLuckAddon[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_DropVIPAddon> g_DropVIPAddon;
	
    public static Tab_DropVIPAddon GetDropVIPAddonByID(int nKey, int nIndex = 0)
    {
        if(g_DropVIPAddon == null)
            InitTable_DropVIPAddon();
		Tab_DropVIPAddon result;
		g_DropVIPAddon.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_DropVIPAddon> GetDropVIPAddon()
    {
        if(g_DropVIPAddon == null)
            InitTable_DropVIPAddon();
        return g_DropVIPAddon;
    }
	
    public static bool InitTable_DropVIPAddon()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_DropVIPAddon.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_DropVIPAddon.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_DropVIPAddon.Validate(lines[1]))
			{
				g_DropVIPAddon = new Dictionary<int, Tab_DropVIPAddon>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_DropVIPAddon(line);
						g_DropVIPAddon[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_DynamicObstacle> g_DynamicObstacle;
	
    public static Tab_DynamicObstacle GetDynamicObstacleByID(int nKey, int nIndex = 0)
    {
        if(g_DynamicObstacle == null)
            InitTable_DynamicObstacle();
		Tab_DynamicObstacle result;
		g_DynamicObstacle.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_DynamicObstacle> GetDynamicObstacle()
    {
        if(g_DynamicObstacle == null)
            InitTable_DynamicObstacle();
        return g_DynamicObstacle;
    }
	
    public static bool InitTable_DynamicObstacle()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_DynamicObstacle.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_DynamicObstacle.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_DynamicObstacle.Validate(lines[1]))
			{
				g_DynamicObstacle = new Dictionary<int, Tab_DynamicObstacle>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_DynamicObstacle(line);
						g_DynamicObstacle[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Effect> g_Effect;
	
    public static Tab_Effect GetEffectByID(int nKey, int nIndex = 0)
    {
        if(g_Effect == null)
            InitTable_Effect();
		Tab_Effect result;
		g_Effect.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Effect> GetEffect()
    {
        if(g_Effect == null)
            InitTable_Effect();
        return g_Effect;
    }
	
    public static bool InitTable_Effect()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Effect.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Effect.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Effect.Validate(lines[1]))
			{
				g_Effect = new Dictionary<int, Tab_Effect>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Effect(line);
						g_Effect[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EffectParam> g_EffectParam;
	
    public static Tab_EffectParam GetEffectParamByID(int nKey, int nIndex = 0)
    {
        if(g_EffectParam == null)
            InitTable_EffectParam();
		Tab_EffectParam result;
		g_EffectParam.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EffectParam> GetEffectParam()
    {
        if(g_EffectParam == null)
            InitTable_EffectParam();
        return g_EffectParam;
    }
	
    public static bool InitTable_EffectParam()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EffectParam.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EffectParam.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EffectParam.Validate(lines[1]))
			{
				g_EffectParam = new Dictionary<int, Tab_EffectParam>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EffectParam(line);
						g_EffectParam[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EffectPoint> g_EffectPoint;
	
    public static Tab_EffectPoint GetEffectPointByID(int nKey, int nIndex = 0)
    {
        if(g_EffectPoint == null)
            InitTable_EffectPoint();
		Tab_EffectPoint result;
		g_EffectPoint.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EffectPoint> GetEffectPoint()
    {
        if(g_EffectPoint == null)
            InitTable_EffectPoint();
        return g_EffectPoint;
    }
	
    public static bool InitTable_EffectPoint()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EffectPoint.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EffectPoint.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EffectPoint.Validate(lines[1]))
			{
				g_EffectPoint = new Dictionary<int, Tab_EffectPoint>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EffectPoint(line);
						g_EffectPoint[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipAttr> g_EquipAttr;
	
    public static Tab_EquipAttr GetEquipAttrByID(int nKey, int nIndex = 0)
    {
        if(g_EquipAttr == null)
            InitTable_EquipAttr();
		Tab_EquipAttr result;
		g_EquipAttr.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipAttr> GetEquipAttr()
    {
        if(g_EquipAttr == null)
            InitTable_EquipAttr();
        return g_EquipAttr;
    }
	
    public static bool InitTable_EquipAttr()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipAttr.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipAttr.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipAttr.Validate(lines[1]))
			{
				g_EquipAttr = new Dictionary<int, Tab_EquipAttr>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipAttr(line);
						g_EquipAttr[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipBaptize> g_EquipBaptize;
	
    public static Tab_EquipBaptize GetEquipBaptizeByID(int nKey, int nIndex = 0)
    {
        if(g_EquipBaptize == null)
            InitTable_EquipBaptize();
		Tab_EquipBaptize result;
		g_EquipBaptize.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipBaptize> GetEquipBaptize()
    {
        if(g_EquipBaptize == null)
            InitTable_EquipBaptize();
        return g_EquipBaptize;
    }
	
    public static bool InitTable_EquipBaptize()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipBaptize.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipBaptize.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipBaptize.Validate(lines[1]))
			{
				g_EquipBaptize = new Dictionary<int, Tab_EquipBaptize>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipBaptize(line);
						g_EquipBaptize[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_EquipBaptizePropName>> g_EquipBaptizePropName;
	
	public static List<Tab_EquipBaptizePropName> GetEquipBaptizePropNameByID(int nKey)
    {
        if(g_EquipBaptizePropName == null)
            InitTable_EquipBaptizePropName();
		List<Tab_EquipBaptizePropName> result;
		g_EquipBaptizePropName.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_EquipBaptizePropName GetEquipBaptizePropNameByID(int nKey, int nIndex)
    {
        if(g_EquipBaptizePropName == null)
            InitTable_EquipBaptizePropName();
		List<Tab_EquipBaptizePropName> list;
		Tab_EquipBaptizePropName result = null;
		if (nIndex >= 0 &&
			g_EquipBaptizePropName.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_EquipBaptizePropName>> GetEquipBaptizePropName()
    {
        if(g_EquipBaptizePropName == null)
            InitTable_EquipBaptizePropName();
        return g_EquipBaptizePropName;
    }
	
	public static bool InitTable_EquipBaptizePropName()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipBaptizePropName.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipBaptizePropName.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipBaptizePropName.Validate(lines[1]))
			{
				g_EquipBaptizePropName = new Dictionary<int, List<Tab_EquipBaptizePropName>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipBaptizePropName(line);
						List<Tab_EquipBaptizePropName> list;
						var id = item.GetId();
						if (!g_EquipBaptizePropName.TryGetValue(id, out list))
						{
							list = new List<Tab_EquipBaptizePropName>();
							g_EquipBaptizePropName.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_EquipBaptizeReplaceTarget>> g_EquipBaptizeReplaceTarget;
	
	public static List<Tab_EquipBaptizeReplaceTarget> GetEquipBaptizeReplaceTargetByID(int nKey)
    {
        if(g_EquipBaptizeReplaceTarget == null)
            InitTable_EquipBaptizeReplaceTarget();
		List<Tab_EquipBaptizeReplaceTarget> result;
		g_EquipBaptizeReplaceTarget.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_EquipBaptizeReplaceTarget GetEquipBaptizeReplaceTargetByID(int nKey, int nIndex)
    {
        if(g_EquipBaptizeReplaceTarget == null)
            InitTable_EquipBaptizeReplaceTarget();
		List<Tab_EquipBaptizeReplaceTarget> list;
		Tab_EquipBaptizeReplaceTarget result = null;
		if (nIndex >= 0 &&
			g_EquipBaptizeReplaceTarget.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_EquipBaptizeReplaceTarget>> GetEquipBaptizeReplaceTarget()
    {
        if(g_EquipBaptizeReplaceTarget == null)
            InitTable_EquipBaptizeReplaceTarget();
        return g_EquipBaptizeReplaceTarget;
    }
	
	public static bool InitTable_EquipBaptizeReplaceTarget()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipBaptizeReplaceTarget.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipBaptizeReplaceTarget.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipBaptizeReplaceTarget.Validate(lines[1]))
			{
				g_EquipBaptizeReplaceTarget = new Dictionary<int, List<Tab_EquipBaptizeReplaceTarget>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipBaptizeReplaceTarget(line);
						List<Tab_EquipBaptizeReplaceTarget> list;
						var id = item.GetId();
						if (!g_EquipBaptizeReplaceTarget.TryGetValue(id, out list))
						{
							list = new List<Tab_EquipBaptizeReplaceTarget>();
							g_EquipBaptizeReplaceTarget.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_EquipBaptizeTarget>> g_EquipBaptizeTarget;
	
	public static List<Tab_EquipBaptizeTarget> GetEquipBaptizeTargetByID(int nKey)
    {
        if(g_EquipBaptizeTarget == null)
            InitTable_EquipBaptizeTarget();
		List<Tab_EquipBaptizeTarget> result;
		g_EquipBaptizeTarget.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_EquipBaptizeTarget GetEquipBaptizeTargetByID(int nKey, int nIndex)
    {
        if(g_EquipBaptizeTarget == null)
            InitTable_EquipBaptizeTarget();
		List<Tab_EquipBaptizeTarget> list;
		Tab_EquipBaptizeTarget result = null;
		if (nIndex >= 0 &&
			g_EquipBaptizeTarget.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_EquipBaptizeTarget>> GetEquipBaptizeTarget()
    {
        if(g_EquipBaptizeTarget == null)
            InitTable_EquipBaptizeTarget();
        return g_EquipBaptizeTarget;
    }
	
	public static bool InitTable_EquipBaptizeTarget()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipBaptizeTarget.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipBaptizeTarget.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipBaptizeTarget.Validate(lines[1]))
			{
				g_EquipBaptizeTarget = new Dictionary<int, List<Tab_EquipBaptizeTarget>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipBaptizeTarget(line);
						List<Tab_EquipBaptizeTarget> list;
						var id = item.GetId();
						if (!g_EquipBaptizeTarget.TryGetValue(id, out list))
						{
							list = new List<Tab_EquipBaptizeTarget>();
							g_EquipBaptizeTarget.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipBasicBaptizeConsume> g_EquipBasicBaptizeConsume;
	
    public static Tab_EquipBasicBaptizeConsume GetEquipBasicBaptizeConsumeByID(int nKey, int nIndex = 0)
    {
        if(g_EquipBasicBaptizeConsume == null)
            InitTable_EquipBasicBaptizeConsume();
		Tab_EquipBasicBaptizeConsume result;
		g_EquipBasicBaptizeConsume.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipBasicBaptizeConsume> GetEquipBasicBaptizeConsume()
    {
        if(g_EquipBasicBaptizeConsume == null)
            InitTable_EquipBasicBaptizeConsume();
        return g_EquipBasicBaptizeConsume;
    }
	
    public static bool InitTable_EquipBasicBaptizeConsume()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipBasicBaptizeConsume.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipBasicBaptizeConsume.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipBasicBaptizeConsume.Validate(lines[1]))
			{
				g_EquipBasicBaptizeConsume = new Dictionary<int, Tab_EquipBasicBaptizeConsume>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipBasicBaptizeConsume(line);
						g_EquipBasicBaptizeConsume[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipDecomposition> g_EquipDecomposition;
	
    public static Tab_EquipDecomposition GetEquipDecompositionByID(int nKey, int nIndex = 0)
    {
        if(g_EquipDecomposition == null)
            InitTable_EquipDecomposition();
		Tab_EquipDecomposition result;
		g_EquipDecomposition.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipDecomposition> GetEquipDecomposition()
    {
        if(g_EquipDecomposition == null)
            InitTable_EquipDecomposition();
        return g_EquipDecomposition;
    }
	
    public static bool InitTable_EquipDecomposition()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipDecomposition.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipDecomposition.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipDecomposition.Validate(lines[1]))
			{
				g_EquipDecomposition = new Dictionary<int, Tab_EquipDecomposition>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipDecomposition(line);
						g_EquipDecomposition[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipEnchanceLvUpConsume> g_EquipEnchanceLvUpConsume;
	
    public static Tab_EquipEnchanceLvUpConsume GetEquipEnchanceLvUpConsumeByID(int nKey, int nIndex = 0)
    {
        if(g_EquipEnchanceLvUpConsume == null)
            InitTable_EquipEnchanceLvUpConsume();
		Tab_EquipEnchanceLvUpConsume result;
		g_EquipEnchanceLvUpConsume.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipEnchanceLvUpConsume> GetEquipEnchanceLvUpConsume()
    {
        if(g_EquipEnchanceLvUpConsume == null)
            InitTable_EquipEnchanceLvUpConsume();
        return g_EquipEnchanceLvUpConsume;
    }
	
    public static bool InitTable_EquipEnchanceLvUpConsume()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipEnchanceLvUpConsume.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipEnchanceLvUpConsume.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipEnchanceLvUpConsume.Validate(lines[1]))
			{
				g_EquipEnchanceLvUpConsume = new Dictionary<int, Tab_EquipEnchanceLvUpConsume>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipEnchanceLvUpConsume(line);
						g_EquipEnchanceLvUpConsume[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipEnchancePerfect> g_EquipEnchancePerfect;
	
    public static Tab_EquipEnchancePerfect GetEquipEnchancePerfectByID(int nKey, int nIndex = 0)
    {
        if(g_EquipEnchancePerfect == null)
            InitTable_EquipEnchancePerfect();
		Tab_EquipEnchancePerfect result;
		g_EquipEnchancePerfect.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipEnchancePerfect> GetEquipEnchancePerfect()
    {
        if(g_EquipEnchancePerfect == null)
            InitTable_EquipEnchancePerfect();
        return g_EquipEnchancePerfect;
    }
	
    public static bool InitTable_EquipEnchancePerfect()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipEnchancePerfect.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipEnchancePerfect.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipEnchancePerfect.Validate(lines[1]))
			{
				g_EquipEnchancePerfect = new Dictionary<int, Tab_EquipEnchancePerfect>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipEnchancePerfect(line);
						g_EquipEnchancePerfect[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipEnchanceRandRate> g_EquipEnchanceRandRate;
	
    public static Tab_EquipEnchanceRandRate GetEquipEnchanceRandRateByID(int nKey, int nIndex = 0)
    {
        if(g_EquipEnchanceRandRate == null)
            InitTable_EquipEnchanceRandRate();
		Tab_EquipEnchanceRandRate result;
		g_EquipEnchanceRandRate.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipEnchanceRandRate> GetEquipEnchanceRandRate()
    {
        if(g_EquipEnchanceRandRate == null)
            InitTable_EquipEnchanceRandRate();
        return g_EquipEnchanceRandRate;
    }
	
    public static bool InitTable_EquipEnchanceRandRate()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipEnchanceRandRate.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipEnchanceRandRate.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipEnchanceRandRate.Validate(lines[1]))
			{
				g_EquipEnchanceRandRate = new Dictionary<int, Tab_EquipEnchanceRandRate>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipEnchanceRandRate(line);
						g_EquipEnchanceRandRate[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipEnchanceSuit> g_EquipEnchanceSuit;
	
    public static Tab_EquipEnchanceSuit GetEquipEnchanceSuitByID(int nKey, int nIndex = 0)
    {
        if(g_EquipEnchanceSuit == null)
            InitTable_EquipEnchanceSuit();
		Tab_EquipEnchanceSuit result;
		g_EquipEnchanceSuit.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipEnchanceSuit> GetEquipEnchanceSuit()
    {
        if(g_EquipEnchanceSuit == null)
            InitTable_EquipEnchanceSuit();
        return g_EquipEnchanceSuit;
    }
	
    public static bool InitTable_EquipEnchanceSuit()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipEnchanceSuit.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipEnchanceSuit.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipEnchanceSuit.Validate(lines[1]))
			{
				g_EquipEnchanceSuit = new Dictionary<int, Tab_EquipEnchanceSuit>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipEnchanceSuit(line);
						g_EquipEnchanceSuit[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipEnchanceTransfer> g_EquipEnchanceTransfer;
	
    public static Tab_EquipEnchanceTransfer GetEquipEnchanceTransferByID(int nKey, int nIndex = 0)
    {
        if(g_EquipEnchanceTransfer == null)
            InitTable_EquipEnchanceTransfer();
		Tab_EquipEnchanceTransfer result;
		g_EquipEnchanceTransfer.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipEnchanceTransfer> GetEquipEnchanceTransfer()
    {
        if(g_EquipEnchanceTransfer == null)
            InitTable_EquipEnchanceTransfer();
        return g_EquipEnchanceTransfer;
    }
	
    public static bool InitTable_EquipEnchanceTransfer()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipEnchanceTransfer.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipEnchanceTransfer.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipEnchanceTransfer.Validate(lines[1]))
			{
				g_EquipEnchanceTransfer = new Dictionary<int, Tab_EquipEnchanceTransfer>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipEnchanceTransfer(line);
						g_EquipEnchanceTransfer[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipFixedPropID> g_EquipFixedPropID;
	
    public static Tab_EquipFixedPropID GetEquipFixedPropIDByID(int nKey, int nIndex = 0)
    {
        if(g_EquipFixedPropID == null)
            InitTable_EquipFixedPropID();
		Tab_EquipFixedPropID result;
		g_EquipFixedPropID.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipFixedPropID> GetEquipFixedPropID()
    {
        if(g_EquipFixedPropID == null)
            InitTable_EquipFixedPropID();
        return g_EquipFixedPropID;
    }
	
    public static bool InitTable_EquipFixedPropID()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipFixedPropID.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipFixedPropID.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipFixedPropID.Validate(lines[1]))
			{
				g_EquipFixedPropID = new Dictionary<int, Tab_EquipFixedPropID>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipFixedPropID(line);
						g_EquipFixedPropID[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipFrenzy> g_EquipFrenzy;
	
    public static Tab_EquipFrenzy GetEquipFrenzyByID(int nKey, int nIndex = 0)
    {
        if(g_EquipFrenzy == null)
            InitTable_EquipFrenzy();
		Tab_EquipFrenzy result;
		g_EquipFrenzy.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipFrenzy> GetEquipFrenzy()
    {
        if(g_EquipFrenzy == null)
            InitTable_EquipFrenzy();
        return g_EquipFrenzy;
    }
	
    public static bool InitTable_EquipFrenzy()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipFrenzy.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipFrenzy.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipFrenzy.Validate(lines[1]))
			{
				g_EquipFrenzy = new Dictionary<int, Tab_EquipFrenzy>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipFrenzy(line);
						g_EquipFrenzy[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipInvalidExpireTime> g_EquipInvalidExpireTime;
	
    public static Tab_EquipInvalidExpireTime GetEquipInvalidExpireTimeByID(int nKey, int nIndex = 0)
    {
        if(g_EquipInvalidExpireTime == null)
            InitTable_EquipInvalidExpireTime();
		Tab_EquipInvalidExpireTime result;
		g_EquipInvalidExpireTime.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipInvalidExpireTime> GetEquipInvalidExpireTime()
    {
        if(g_EquipInvalidExpireTime == null)
            InitTable_EquipInvalidExpireTime();
        return g_EquipInvalidExpireTime;
    }
	
    public static bool InitTable_EquipInvalidExpireTime()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipInvalidExpireTime.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipInvalidExpireTime.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipInvalidExpireTime.Validate(lines[1]))
			{
				g_EquipInvalidExpireTime = new Dictionary<int, Tab_EquipInvalidExpireTime>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipInvalidExpireTime(line);
						g_EquipInvalidExpireTime[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipPropBarBaptizeConsume> g_EquipPropBarBaptizeConsume;
	
    public static Tab_EquipPropBarBaptizeConsume GetEquipPropBarBaptizeConsumeByID(int nKey, int nIndex = 0)
    {
        if(g_EquipPropBarBaptizeConsume == null)
            InitTable_EquipPropBarBaptizeConsume();
		Tab_EquipPropBarBaptizeConsume result;
		g_EquipPropBarBaptizeConsume.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipPropBarBaptizeConsume> GetEquipPropBarBaptizeConsume()
    {
        if(g_EquipPropBarBaptizeConsume == null)
            InitTable_EquipPropBarBaptizeConsume();
        return g_EquipPropBarBaptizeConsume;
    }
	
    public static bool InitTable_EquipPropBarBaptizeConsume()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipPropBarBaptizeConsume.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipPropBarBaptizeConsume.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipPropBarBaptizeConsume.Validate(lines[1]))
			{
				g_EquipPropBarBaptizeConsume = new Dictionary<int, Tab_EquipPropBarBaptizeConsume>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipPropBarBaptizeConsume(line);
						g_EquipPropBarBaptizeConsume[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipPropBarReplaceConsume> g_EquipPropBarReplaceConsume;
	
    public static Tab_EquipPropBarReplaceConsume GetEquipPropBarReplaceConsumeByID(int nKey, int nIndex = 0)
    {
        if(g_EquipPropBarReplaceConsume == null)
            InitTable_EquipPropBarReplaceConsume();
		Tab_EquipPropBarReplaceConsume result;
		g_EquipPropBarReplaceConsume.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipPropBarReplaceConsume> GetEquipPropBarReplaceConsume()
    {
        if(g_EquipPropBarReplaceConsume == null)
            InitTable_EquipPropBarReplaceConsume();
        return g_EquipPropBarReplaceConsume;
    }
	
    public static bool InitTable_EquipPropBarReplaceConsume()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipPropBarReplaceConsume.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipPropBarReplaceConsume.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipPropBarReplaceConsume.Validate(lines[1]))
			{
				g_EquipPropBarReplaceConsume = new Dictionary<int, Tab_EquipPropBarReplaceConsume>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipPropBarReplaceConsume(line);
						g_EquipPropBarReplaceConsume[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipPunchConsume> g_EquipPunchConsume;
	
    public static Tab_EquipPunchConsume GetEquipPunchConsumeByID(int nKey, int nIndex = 0)
    {
        if(g_EquipPunchConsume == null)
            InitTable_EquipPunchConsume();
		Tab_EquipPunchConsume result;
		g_EquipPunchConsume.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipPunchConsume> GetEquipPunchConsume()
    {
        if(g_EquipPunchConsume == null)
            InitTable_EquipPunchConsume();
        return g_EquipPunchConsume;
    }
	
    public static bool InitTable_EquipPunchConsume()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipPunchConsume.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipPunchConsume.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipPunchConsume.Validate(lines[1]))
			{
				g_EquipPunchConsume = new Dictionary<int, Tab_EquipPunchConsume>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipPunchConsume(line);
						g_EquipPunchConsume[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_EquipScore> g_EquipScore;
	
    public static Tab_EquipScore GetEquipScoreByID(int nKey, int nIndex = 0)
    {
        if(g_EquipScore == null)
            InitTable_EquipScore();
		Tab_EquipScore result;
		g_EquipScore.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_EquipScore> GetEquipScore()
    {
        if(g_EquipScore == null)
            InitTable_EquipScore();
        return g_EquipScore;
    }
	
    public static bool InitTable_EquipScore()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_EquipScore.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_EquipScore.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_EquipScore.Validate(lines[1]))
			{
				g_EquipScore = new Dictionary<int, Tab_EquipScore>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_EquipScore(line);
						g_EquipScore[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Escort> g_Escort;
	
    public static Tab_Escort GetEscortByID(int nKey, int nIndex = 0)
    {
        if(g_Escort == null)
            InitTable_Escort();
		Tab_Escort result;
		g_Escort.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Escort> GetEscort()
    {
        if(g_Escort == null)
            InitTable_Escort();
        return g_Escort;
    }
	
    public static bool InitTable_Escort()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Escort.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Escort.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Escort.Validate(lines[1]))
			{
				g_Escort = new Dictionary<int, Tab_Escort>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Escort(line);
						g_Escort[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ExchangeMarket> g_ExchangeMarket;
	
    public static Tab_ExchangeMarket GetExchangeMarketByID(int nKey, int nIndex = 0)
    {
        if(g_ExchangeMarket == null)
            InitTable_ExchangeMarket();
		Tab_ExchangeMarket result;
		g_ExchangeMarket.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ExchangeMarket> GetExchangeMarket()
    {
        if(g_ExchangeMarket == null)
            InitTable_ExchangeMarket();
        return g_ExchangeMarket;
    }
	
    public static bool InitTable_ExchangeMarket()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ExchangeMarket.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ExchangeMarket.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ExchangeMarket.Validate(lines[1]))
			{
				g_ExchangeMarket = new Dictionary<int, Tab_ExchangeMarket>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ExchangeMarket(line);
						g_ExchangeMarket[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ExerciseRoom> g_ExerciseRoom;
	
    public static Tab_ExerciseRoom GetExerciseRoomByID(int nKey, int nIndex = 0)
    {
        if(g_ExerciseRoom == null)
            InitTable_ExerciseRoom();
		Tab_ExerciseRoom result;
		g_ExerciseRoom.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ExerciseRoom> GetExerciseRoom()
    {
        if(g_ExerciseRoom == null)
            InitTable_ExerciseRoom();
        return g_ExerciseRoom;
    }
	
    public static bool InitTable_ExerciseRoom()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ExerciseRoom.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ExerciseRoom.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ExerciseRoom.Validate(lines[1]))
			{
				g_ExerciseRoom = new Dictionary<int, Tab_ExerciseRoom>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ExerciseRoom(line);
						g_ExerciseRoom[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ExerciseRoomSetUp> g_ExerciseRoomSetUp;
	
    public static Tab_ExerciseRoomSetUp GetExerciseRoomSetUpByID(int nKey, int nIndex = 0)
    {
        if(g_ExerciseRoomSetUp == null)
            InitTable_ExerciseRoomSetUp();
		Tab_ExerciseRoomSetUp result;
		g_ExerciseRoomSetUp.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ExerciseRoomSetUp> GetExerciseRoomSetUp()
    {
        if(g_ExerciseRoomSetUp == null)
            InitTable_ExerciseRoomSetUp();
        return g_ExerciseRoomSetUp;
    }
	
    public static bool InitTable_ExerciseRoomSetUp()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ExerciseRoomSetUp.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ExerciseRoomSetUp.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ExerciseRoomSetUp.Validate(lines[1]))
			{
				g_ExerciseRoomSetUp = new Dictionary<int, Tab_ExerciseRoomSetUp>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ExerciseRoomSetUp(line);
						g_ExerciseRoomSetUp[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FactionAdvanceCopy> g_FactionAdvanceCopy;
	
    public static Tab_FactionAdvanceCopy GetFactionAdvanceCopyByID(int nKey, int nIndex = 0)
    {
        if(g_FactionAdvanceCopy == null)
            InitTable_FactionAdvanceCopy();
		Tab_FactionAdvanceCopy result;
		g_FactionAdvanceCopy.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FactionAdvanceCopy> GetFactionAdvanceCopy()
    {
        if(g_FactionAdvanceCopy == null)
            InitTable_FactionAdvanceCopy();
        return g_FactionAdvanceCopy;
    }
	
    public static bool InitTable_FactionAdvanceCopy()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FactionAdvanceCopy.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FactionAdvanceCopy.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FactionAdvanceCopy.Validate(lines[1]))
			{
				g_FactionAdvanceCopy = new Dictionary<int, Tab_FactionAdvanceCopy>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FactionAdvanceCopy(line);
						g_FactionAdvanceCopy[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FactionAdvanceOther> g_FactionAdvanceOther;
	
    public static Tab_FactionAdvanceOther GetFactionAdvanceOtherByID(int nKey, int nIndex = 0)
    {
        if(g_FactionAdvanceOther == null)
            InitTable_FactionAdvanceOther();
		Tab_FactionAdvanceOther result;
		g_FactionAdvanceOther.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FactionAdvanceOther> GetFactionAdvanceOther()
    {
        if(g_FactionAdvanceOther == null)
            InitTable_FactionAdvanceOther();
        return g_FactionAdvanceOther;
    }
	
    public static bool InitTable_FactionAdvanceOther()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FactionAdvanceOther.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FactionAdvanceOther.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FactionAdvanceOther.Validate(lines[1]))
			{
				g_FactionAdvanceOther = new Dictionary<int, Tab_FactionAdvanceOther>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FactionAdvanceOther(line);
						g_FactionAdvanceOther[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FakeObject> g_FakeObject;
	
    public static Tab_FakeObject GetFakeObjectByID(int nKey, int nIndex = 0)
    {
        if(g_FakeObject == null)
            InitTable_FakeObject();
		Tab_FakeObject result;
		g_FakeObject.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FakeObject> GetFakeObject()
    {
        if(g_FakeObject == null)
            InitTable_FakeObject();
        return g_FakeObject;
    }
	
    public static bool InitTable_FakeObject()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FakeObject.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FakeObject.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FakeObject.Validate(lines[1]))
			{
				g_FakeObject = new Dictionary<int, Tab_FakeObject>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FakeObject(line);
						g_FakeObject[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FashionItem> g_FashionItem;
	
    public static Tab_FashionItem GetFashionItemByID(int nKey, int nIndex = 0)
    {
        if(g_FashionItem == null)
            InitTable_FashionItem();
		Tab_FashionItem result;
		g_FashionItem.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FashionItem> GetFashionItem()
    {
        if(g_FashionItem == null)
            InitTable_FashionItem();
        return g_FashionItem;
    }
	
    public static bool InitTable_FashionItem()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FashionItem.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FashionItem.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FashionItem.Validate(lines[1]))
			{
				g_FashionItem = new Dictionary<int, Tab_FashionItem>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FashionItem(line);
						g_FashionItem[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FellowApitute> g_FellowApitute;
	
    public static Tab_FellowApitute GetFellowApituteByID(int nKey, int nIndex = 0)
    {
        if(g_FellowApitute == null)
            InitTable_FellowApitute();
		Tab_FellowApitute result;
		g_FellowApitute.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FellowApitute> GetFellowApitute()
    {
        if(g_FellowApitute == null)
            InitTable_FellowApitute();
        return g_FellowApitute;
    }
	
    public static bool InitTable_FellowApitute()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FellowApitute.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FellowApitute.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FellowApitute.Validate(lines[1]))
			{
				g_FellowApitute = new Dictionary<int, Tab_FellowApitute>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FellowApitute(line);
						g_FellowApitute[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FellowAttached> g_FellowAttached;
	
    public static Tab_FellowAttached GetFellowAttachedByID(int nKey, int nIndex = 0)
    {
        if(g_FellowAttached == null)
            InitTable_FellowAttached();
		Tab_FellowAttached result;
		g_FellowAttached.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FellowAttached> GetFellowAttached()
    {
        if(g_FellowAttached == null)
            InitTable_FellowAttached();
        return g_FellowAttached;
    }
	
    public static bool InitTable_FellowAttached()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FellowAttached.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FellowAttached.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FellowAttached.Validate(lines[1]))
			{
				g_FellowAttached = new Dictionary<int, Tab_FellowAttached>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FellowAttached(line);
						g_FellowAttached[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FellowBase> g_FellowBase;
	
    public static Tab_FellowBase GetFellowBaseByID(int nKey, int nIndex = 0)
    {
        if(g_FellowBase == null)
            InitTable_FellowBase();
		Tab_FellowBase result;
		g_FellowBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FellowBase> GetFellowBase()
    {
        if(g_FellowBase == null)
            InitTable_FellowBase();
        return g_FellowBase;
    }
	
    public static bool InitTable_FellowBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FellowBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FellowBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FellowBase.Validate(lines[1]))
			{
				g_FellowBase = new Dictionary<int, Tab_FellowBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FellowBase(line);
						g_FellowBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_FellowDialog>> g_FellowDialog;
	
	public static List<Tab_FellowDialog> GetFellowDialogByID(int nKey)
    {
        if(g_FellowDialog == null)
            InitTable_FellowDialog();
		List<Tab_FellowDialog> result;
		g_FellowDialog.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_FellowDialog GetFellowDialogByID(int nKey, int nIndex)
    {
        if(g_FellowDialog == null)
            InitTable_FellowDialog();
		List<Tab_FellowDialog> list;
		Tab_FellowDialog result = null;
		if (nIndex >= 0 &&
			g_FellowDialog.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_FellowDialog>> GetFellowDialog()
    {
        if(g_FellowDialog == null)
            InitTable_FellowDialog();
        return g_FellowDialog;
    }
	
	public static bool InitTable_FellowDialog()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FellowDialog.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FellowDialog.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FellowDialog.Validate(lines[1]))
			{
				g_FellowDialog = new Dictionary<int, List<Tab_FellowDialog>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FellowDialog(line);
						List<Tab_FellowDialog> list;
						var id = item.GetId();
						if (!g_FellowDialog.TryGetValue(id, out list))
						{
							list = new List<Tab_FellowDialog>();
							g_FellowDialog.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FellowGrow> g_FellowGrow;
	
    public static Tab_FellowGrow GetFellowGrowByID(int nKey, int nIndex = 0)
    {
        if(g_FellowGrow == null)
            InitTable_FellowGrow();
		Tab_FellowGrow result;
		g_FellowGrow.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FellowGrow> GetFellowGrow()
    {
        if(g_FellowGrow == null)
            InitTable_FellowGrow();
        return g_FellowGrow;
    }
	
    public static bool InitTable_FellowGrow()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FellowGrow.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FellowGrow.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FellowGrow.Validate(lines[1]))
			{
				g_FellowGrow = new Dictionary<int, Tab_FellowGrow>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FellowGrow(line);
						g_FellowGrow[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FellowHandBook> g_FellowHandBook;
	
    public static Tab_FellowHandBook GetFellowHandBookByID(int nKey, int nIndex = 0)
    {
        if(g_FellowHandBook == null)
            InitTable_FellowHandBook();
		Tab_FellowHandBook result;
		g_FellowHandBook.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FellowHandBook> GetFellowHandBook()
    {
        if(g_FellowHandBook == null)
            InitTable_FellowHandBook();
        return g_FellowHandBook;
    }
	
    public static bool InitTable_FellowHandBook()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FellowHandBook.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FellowHandBook.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FellowHandBook.Validate(lines[1]))
			{
				g_FellowHandBook = new Dictionary<int, Tab_FellowHandBook>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FellowHandBook(line);
						g_FellowHandBook[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FellowLearnSkillAttr> g_FellowLearnSkillAttr;
	
    public static Tab_FellowLearnSkillAttr GetFellowLearnSkillAttrByID(int nKey, int nIndex = 0)
    {
        if(g_FellowLearnSkillAttr == null)
            InitTable_FellowLearnSkillAttr();
		Tab_FellowLearnSkillAttr result;
		g_FellowLearnSkillAttr.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FellowLearnSkillAttr> GetFellowLearnSkillAttr()
    {
        if(g_FellowLearnSkillAttr == null)
            InitTable_FellowLearnSkillAttr();
        return g_FellowLearnSkillAttr;
    }
	
    public static bool InitTable_FellowLearnSkillAttr()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FellowLearnSkillAttr.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FellowLearnSkillAttr.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FellowLearnSkillAttr.Validate(lines[1]))
			{
				g_FellowLearnSkillAttr = new Dictionary<int, Tab_FellowLearnSkillAttr>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FellowLearnSkillAttr(line);
						g_FellowLearnSkillAttr[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FellowLearnSkillCost> g_FellowLearnSkillCost;
	
    public static Tab_FellowLearnSkillCost GetFellowLearnSkillCostByID(int nKey, int nIndex = 0)
    {
        if(g_FellowLearnSkillCost == null)
            InitTable_FellowLearnSkillCost();
		Tab_FellowLearnSkillCost result;
		g_FellowLearnSkillCost.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FellowLearnSkillCost> GetFellowLearnSkillCost()
    {
        if(g_FellowLearnSkillCost == null)
            InitTable_FellowLearnSkillCost();
        return g_FellowLearnSkillCost;
    }
	
    public static bool InitTable_FellowLearnSkillCost()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FellowLearnSkillCost.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FellowLearnSkillCost.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FellowLearnSkillCost.Validate(lines[1]))
			{
				g_FellowLearnSkillCost = new Dictionary<int, Tab_FellowLearnSkillCost>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FellowLearnSkillCost(line);
						g_FellowLearnSkillCost[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FellowSkill> g_FellowSkill;
	
    public static Tab_FellowSkill GetFellowSkillByID(int nKey, int nIndex = 0)
    {
        if(g_FellowSkill == null)
            InitTable_FellowSkill();
		Tab_FellowSkill result;
		g_FellowSkill.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FellowSkill> GetFellowSkill()
    {
        if(g_FellowSkill == null)
            InitTable_FellowSkill();
        return g_FellowSkill;
    }
	
    public static bool InitTable_FellowSkill()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FellowSkill.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FellowSkill.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FellowSkill.Validate(lines[1]))
			{
				g_FellowSkill = new Dictionary<int, Tab_FellowSkill>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FellowSkill(line);
						g_FellowSkill[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FellowSkillLimit> g_FellowSkillLimit;
	
    public static Tab_FellowSkillLimit GetFellowSkillLimitByID(int nKey, int nIndex = 0)
    {
        if(g_FellowSkillLimit == null)
            InitTable_FellowSkillLimit();
		Tab_FellowSkillLimit result;
		g_FellowSkillLimit.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FellowSkillLimit> GetFellowSkillLimit()
    {
        if(g_FellowSkillLimit == null)
            InitTable_FellowSkillLimit();
        return g_FellowSkillLimit;
    }
	
    public static bool InitTable_FellowSkillLimit()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FellowSkillLimit.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FellowSkillLimit.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FellowSkillLimit.Validate(lines[1]))
			{
				g_FellowSkillLimit = new Dictionary<int, Tab_FellowSkillLimit>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FellowSkillLimit(line);
						g_FellowSkillLimit[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FellowSkillLockNum> g_FellowSkillLockNum;
	
    public static Tab_FellowSkillLockNum GetFellowSkillLockNumByID(int nKey, int nIndex = 0)
    {
        if(g_FellowSkillLockNum == null)
            InitTable_FellowSkillLockNum();
		Tab_FellowSkillLockNum result;
		g_FellowSkillLockNum.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FellowSkillLockNum> GetFellowSkillLockNum()
    {
        if(g_FellowSkillLockNum == null)
            InitTable_FellowSkillLockNum();
        return g_FellowSkillLockNum;
    }
	
    public static bool InitTable_FellowSkillLockNum()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FellowSkillLockNum.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FellowSkillLockNum.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FellowSkillLockNum.Validate(lines[1]))
			{
				g_FellowSkillLockNum = new Dictionary<int, Tab_FellowSkillLockNum>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FellowSkillLockNum(line);
						g_FellowSkillLockNum[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Fuben> g_Fuben;
	
    public static Tab_Fuben GetFubenByID(int nKey, int nIndex = 0)
    {
        if(g_Fuben == null)
            InitTable_Fuben();
		Tab_Fuben result;
		g_Fuben.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Fuben> GetFuben()
    {
        if(g_Fuben == null)
            InitTable_Fuben();
        return g_Fuben;
    }
	
    public static bool InitTable_Fuben()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Fuben.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Fuben.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Fuben.Validate(lines[1]))
			{
				g_Fuben = new Dictionary<int, Tab_Fuben>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Fuben(line);
						g_Fuben[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FunctionOpen> g_FunctionOpen;
	
    public static Tab_FunctionOpen GetFunctionOpenByID(int nKey, int nIndex = 0)
    {
        if(g_FunctionOpen == null)
            InitTable_FunctionOpen();
		Tab_FunctionOpen result;
		g_FunctionOpen.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FunctionOpen> GetFunctionOpen()
    {
        if(g_FunctionOpen == null)
            InitTable_FunctionOpen();
        return g_FunctionOpen;
    }
	
    public static bool InitTable_FunctionOpen()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FunctionOpen.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FunctionOpen.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FunctionOpen.Validate(lines[1]))
			{
				g_FunctionOpen = new Dictionary<int, Tab_FunctionOpen>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FunctionOpen(line);
						g_FunctionOpen[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_FunctionPreview> g_FunctionPreview;
	
    public static Tab_FunctionPreview GetFunctionPreviewByID(int nKey, int nIndex = 0)
    {
        if(g_FunctionPreview == null)
            InitTable_FunctionPreview();
		Tab_FunctionPreview result;
		g_FunctionPreview.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_FunctionPreview> GetFunctionPreview()
    {
        if(g_FunctionPreview == null)
            InitTable_FunctionPreview();
        return g_FunctionPreview;
    }
	
    public static bool InitTable_FunctionPreview()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_FunctionPreview.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_FunctionPreview.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_FunctionPreview.Validate(lines[1]))
			{
				g_FunctionPreview = new Dictionary<int, Tab_FunctionPreview>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_FunctionPreview(line);
						g_FunctionPreview[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GemAttr> g_GemAttr;
	
    public static Tab_GemAttr GetGemAttrByID(int nKey, int nIndex = 0)
    {
        if(g_GemAttr == null)
            InitTable_GemAttr();
		Tab_GemAttr result;
		g_GemAttr.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GemAttr> GetGemAttr()
    {
        if(g_GemAttr == null)
            InitTable_GemAttr();
        return g_GemAttr;
    }
	
    public static bool InitTable_GemAttr()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GemAttr.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GemAttr.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GemAttr.Validate(lines[1]))
			{
				g_GemAttr = new Dictionary<int, Tab_GemAttr>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GemAttr(line);
						g_GemAttr[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GemHoleLimit> g_GemHoleLimit;
	
    public static Tab_GemHoleLimit GetGemHoleLimitByID(int nKey, int nIndex = 0)
    {
        if(g_GemHoleLimit == null)
            InitTable_GemHoleLimit();
		Tab_GemHoleLimit result;
		g_GemHoleLimit.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GemHoleLimit> GetGemHoleLimit()
    {
        if(g_GemHoleLimit == null)
            InitTable_GemHoleLimit();
        return g_GemHoleLimit;
    }
	
    public static bool InitTable_GemHoleLimit()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GemHoleLimit.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GemHoleLimit.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GemHoleLimit.Validate(lines[1]))
			{
				g_GemHoleLimit = new Dictionary<int, Tab_GemHoleLimit>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GemHoleLimit(line);
						g_GemHoleLimit[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GemInlayLvlLimit> g_GemInlayLvlLimit;
	
    public static Tab_GemInlayLvlLimit GetGemInlayLvlLimitByID(int nKey, int nIndex = 0)
    {
        if(g_GemInlayLvlLimit == null)
            InitTable_GemInlayLvlLimit();
		Tab_GemInlayLvlLimit result;
		g_GemInlayLvlLimit.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GemInlayLvlLimit> GetGemInlayLvlLimit()
    {
        if(g_GemInlayLvlLimit == null)
            InitTable_GemInlayLvlLimit();
        return g_GemInlayLvlLimit;
    }
	
    public static bool InitTable_GemInlayLvlLimit()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GemInlayLvlLimit.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GemInlayLvlLimit.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GemInlayLvlLimit.Validate(lines[1]))
			{
				g_GemInlayLvlLimit = new Dictionary<int, Tab_GemInlayLvlLimit>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GemInlayLvlLimit(line);
						g_GemInlayLvlLimit[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GemLvlUpConsume> g_GemLvlUpConsume;
	
    public static Tab_GemLvlUpConsume GetGemLvlUpConsumeByID(int nKey, int nIndex = 0)
    {
        if(g_GemLvlUpConsume == null)
            InitTable_GemLvlUpConsume();
		Tab_GemLvlUpConsume result;
		g_GemLvlUpConsume.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GemLvlUpConsume> GetGemLvlUpConsume()
    {
        if(g_GemLvlUpConsume == null)
            InitTable_GemLvlUpConsume();
        return g_GemLvlUpConsume;
    }
	
    public static bool InitTable_GemLvlUpConsume()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GemLvlUpConsume.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GemLvlUpConsume.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GemLvlUpConsume.Validate(lines[1]))
			{
				g_GemLvlUpConsume = new Dictionary<int, Tab_GemLvlUpConsume>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GemLvlUpConsume(line);
						g_GemLvlUpConsume[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GemProp> g_GemProp;
	
    public static Tab_GemProp GetGemPropByID(int nKey, int nIndex = 0)
    {
        if(g_GemProp == null)
            InitTable_GemProp();
		Tab_GemProp result;
		g_GemProp.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GemProp> GetGemProp()
    {
        if(g_GemProp == null)
            InitTable_GemProp();
        return g_GemProp;
    }
	
    public static bool InitTable_GemProp()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GemProp.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GemProp.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GemProp.Validate(lines[1]))
			{
				g_GemProp = new Dictionary<int, Tab_GemProp>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GemProp(line);
						g_GemProp[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GemSuit> g_GemSuit;
	
    public static Tab_GemSuit GetGemSuitByID(int nKey, int nIndex = 0)
    {
        if(g_GemSuit == null)
            InitTable_GemSuit();
		Tab_GemSuit result;
		g_GemSuit.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GemSuit> GetGemSuit()
    {
        if(g_GemSuit == null)
            InitTable_GemSuit();
        return g_GemSuit;
    }
	
    public static bool InitTable_GemSuit()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GemSuit.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GemSuit.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GemSuit.Validate(lines[1]))
			{
				g_GemSuit = new Dictionary<int, Tab_GemSuit>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GemSuit(line);
						g_GemSuit[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GemSuitInlay> g_GemSuitInlay;
	
    public static Tab_GemSuitInlay GetGemSuitInlayByID(int nKey, int nIndex = 0)
    {
        if(g_GemSuitInlay == null)
            InitTable_GemSuitInlay();
		Tab_GemSuitInlay result;
		g_GemSuitInlay.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GemSuitInlay> GetGemSuitInlay()
    {
        if(g_GemSuitInlay == null)
            InitTable_GemSuitInlay();
        return g_GemSuitInlay;
    }
	
    public static bool InitTable_GemSuitInlay()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GemSuitInlay.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GemSuitInlay.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GemSuitInlay.Validate(lines[1]))
			{
				g_GemSuitInlay = new Dictionary<int, Tab_GemSuitInlay>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GemSuitInlay(line);
						g_GemSuitInlay[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GuildActivityWelfare> g_GuildActivityWelfare;
	
    public static Tab_GuildActivityWelfare GetGuildActivityWelfareByID(int nKey, int nIndex = 0)
    {
        if(g_GuildActivityWelfare == null)
            InitTable_GuildActivityWelfare();
		Tab_GuildActivityWelfare result;
		g_GuildActivityWelfare.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GuildActivityWelfare> GetGuildActivityWelfare()
    {
        if(g_GuildActivityWelfare == null)
            InitTable_GuildActivityWelfare();
        return g_GuildActivityWelfare;
    }
	
    public static bool InitTable_GuildActivityWelfare()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GuildActivityWelfare.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GuildActivityWelfare.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GuildActivityWelfare.Validate(lines[1]))
			{
				g_GuildActivityWelfare = new Dictionary<int, Tab_GuildActivityWelfare>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GuildActivityWelfare(line);
						g_GuildActivityWelfare[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GuildAttrPractice> g_GuildAttrPractice;
	
    public static Tab_GuildAttrPractice GetGuildAttrPracticeByID(int nKey, int nIndex = 0)
    {
        if(g_GuildAttrPractice == null)
            InitTable_GuildAttrPractice();
		Tab_GuildAttrPractice result;
		g_GuildAttrPractice.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GuildAttrPractice> GetGuildAttrPractice()
    {
        if(g_GuildAttrPractice == null)
            InitTable_GuildAttrPractice();
        return g_GuildAttrPractice;
    }
	
    public static bool InitTable_GuildAttrPractice()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GuildAttrPractice.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GuildAttrPractice.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GuildAttrPractice.Validate(lines[1]))
			{
				g_GuildAttrPractice = new Dictionary<int, Tab_GuildAttrPractice>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GuildAttrPractice(line);
						g_GuildAttrPractice[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GuildBossConfig> g_GuildBossConfig;
	
    public static Tab_GuildBossConfig GetGuildBossConfigByID(int nKey, int nIndex = 0)
    {
        if(g_GuildBossConfig == null)
            InitTable_GuildBossConfig();
		Tab_GuildBossConfig result;
		g_GuildBossConfig.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GuildBossConfig> GetGuildBossConfig()
    {
        if(g_GuildBossConfig == null)
            InitTable_GuildBossConfig();
        return g_GuildBossConfig;
    }
	
    public static bool InitTable_GuildBossConfig()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GuildBossConfig.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GuildBossConfig.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GuildBossConfig.Validate(lines[1]))
			{
				g_GuildBossConfig = new Dictionary<int, Tab_GuildBossConfig>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GuildBossConfig(line);
						g_GuildBossConfig[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_GuildBuilding>> g_GuildBuilding;
	
	public static List<Tab_GuildBuilding> GetGuildBuildingByID(int nKey)
    {
        if(g_GuildBuilding == null)
            InitTable_GuildBuilding();
		List<Tab_GuildBuilding> result;
		g_GuildBuilding.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_GuildBuilding GetGuildBuildingByID(int nKey, int nIndex)
    {
        if(g_GuildBuilding == null)
            InitTable_GuildBuilding();
		List<Tab_GuildBuilding> list;
		Tab_GuildBuilding result = null;
		if (nIndex >= 0 &&
			g_GuildBuilding.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_GuildBuilding>> GetGuildBuilding()
    {
        if(g_GuildBuilding == null)
            InitTable_GuildBuilding();
        return g_GuildBuilding;
    }
	
	public static bool InitTable_GuildBuilding()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GuildBuilding.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GuildBuilding.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GuildBuilding.Validate(lines[1]))
			{
				g_GuildBuilding = new Dictionary<int, List<Tab_GuildBuilding>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GuildBuilding(line);
						List<Tab_GuildBuilding> list;
						var id = item.GetId();
						if (!g_GuildBuilding.TryGetValue(id, out list))
						{
							list = new List<Tab_GuildBuilding>();
							g_GuildBuilding.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GuildCollege> g_GuildCollege;
	
    public static Tab_GuildCollege GetGuildCollegeByID(int nKey, int nIndex = 0)
    {
        if(g_GuildCollege == null)
            InitTable_GuildCollege();
		Tab_GuildCollege result;
		g_GuildCollege.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GuildCollege> GetGuildCollege()
    {
        if(g_GuildCollege == null)
            InitTable_GuildCollege();
        return g_GuildCollege;
    }
	
    public static bool InitTable_GuildCollege()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GuildCollege.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GuildCollege.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GuildCollege.Validate(lines[1]))
			{
				g_GuildCollege = new Dictionary<int, Tab_GuildCollege>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GuildCollege(line);
						g_GuildCollege[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GuildFreightOther> g_GuildFreightOther;
	
    public static Tab_GuildFreightOther GetGuildFreightOtherByID(int nKey, int nIndex = 0)
    {
        if(g_GuildFreightOther == null)
            InitTable_GuildFreightOther();
		Tab_GuildFreightOther result;
		g_GuildFreightOther.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GuildFreightOther> GetGuildFreightOther()
    {
        if(g_GuildFreightOther == null)
            InitTable_GuildFreightOther();
        return g_GuildFreightOther;
    }
	
    public static bool InitTable_GuildFreightOther()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GuildFreightOther.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GuildFreightOther.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GuildFreightOther.Validate(lines[1]))
			{
				g_GuildFreightOther = new Dictionary<int, Tab_GuildFreightOther>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GuildFreightOther(line);
						g_GuildFreightOther[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GuildFreightPool> g_GuildFreightPool;
	
    public static Tab_GuildFreightPool GetGuildFreightPoolByID(int nKey, int nIndex = 0)
    {
        if(g_GuildFreightPool == null)
            InitTable_GuildFreightPool();
		Tab_GuildFreightPool result;
		g_GuildFreightPool.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GuildFreightPool> GetGuildFreightPool()
    {
        if(g_GuildFreightPool == null)
            InitTable_GuildFreightPool();
        return g_GuildFreightPool;
    }
	
    public static bool InitTable_GuildFreightPool()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GuildFreightPool.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GuildFreightPool.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GuildFreightPool.Validate(lines[1]))
			{
				g_GuildFreightPool = new Dictionary<int, Tab_GuildFreightPool>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GuildFreightPool(line);
						g_GuildFreightPool[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GuildFreightReward> g_GuildFreightReward;
	
    public static Tab_GuildFreightReward GetGuildFreightRewardByID(int nKey, int nIndex = 0)
    {
        if(g_GuildFreightReward == null)
            InitTable_GuildFreightReward();
		Tab_GuildFreightReward result;
		g_GuildFreightReward.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GuildFreightReward> GetGuildFreightReward()
    {
        if(g_GuildFreightReward == null)
            InitTable_GuildFreightReward();
        return g_GuildFreightReward;
    }
	
    public static bool InitTable_GuildFreightReward()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GuildFreightReward.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GuildFreightReward.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GuildFreightReward.Validate(lines[1]))
			{
				g_GuildFreightReward = new Dictionary<int, Tab_GuildFreightReward>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GuildFreightReward(line);
						g_GuildFreightReward[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GuildHistory> g_GuildHistory;
	
    public static Tab_GuildHistory GetGuildHistoryByID(int nKey, int nIndex = 0)
    {
        if(g_GuildHistory == null)
            InitTable_GuildHistory();
		Tab_GuildHistory result;
		g_GuildHistory.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GuildHistory> GetGuildHistory()
    {
        if(g_GuildHistory == null)
            InitTable_GuildHistory();
        return g_GuildHistory;
    }
	
    public static bool InitTable_GuildHistory()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GuildHistory.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GuildHistory.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GuildHistory.Validate(lines[1]))
			{
				g_GuildHistory = new Dictionary<int, Tab_GuildHistory>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GuildHistory(line);
						g_GuildHistory[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GuildJurisdiction> g_GuildJurisdiction;
	
    public static Tab_GuildJurisdiction GetGuildJurisdictionByID(int nKey, int nIndex = 0)
    {
        if(g_GuildJurisdiction == null)
            InitTable_GuildJurisdiction();
		Tab_GuildJurisdiction result;
		g_GuildJurisdiction.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GuildJurisdiction> GetGuildJurisdiction()
    {
        if(g_GuildJurisdiction == null)
            InitTable_GuildJurisdiction();
        return g_GuildJurisdiction;
    }
	
    public static bool InitTable_GuildJurisdiction()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GuildJurisdiction.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GuildJurisdiction.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GuildJurisdiction.Validate(lines[1]))
			{
				g_GuildJurisdiction = new Dictionary<int, Tab_GuildJurisdiction>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GuildJurisdiction(line);
						g_GuildJurisdiction[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GuildLevelUp> g_GuildLevelUp;
	
    public static Tab_GuildLevelUp GetGuildLevelUpByID(int nKey, int nIndex = 0)
    {
        if(g_GuildLevelUp == null)
            InitTable_GuildLevelUp();
		Tab_GuildLevelUp result;
		g_GuildLevelUp.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GuildLevelUp> GetGuildLevelUp()
    {
        if(g_GuildLevelUp == null)
            InitTable_GuildLevelUp();
        return g_GuildLevelUp;
    }
	
    public static bool InitTable_GuildLevelUp()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GuildLevelUp.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GuildLevelUp.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GuildLevelUp.Validate(lines[1]))
			{
				g_GuildLevelUp = new Dictionary<int, Tab_GuildLevelUp>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GuildLevelUp(line);
						g_GuildLevelUp[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_GuildOther> g_GuildOther;
	
    public static Tab_GuildOther GetGuildOtherByID(int nKey, int nIndex = 0)
    {
        if(g_GuildOther == null)
            InitTable_GuildOther();
		Tab_GuildOther result;
		g_GuildOther.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_GuildOther> GetGuildOther()
    {
        if(g_GuildOther == null)
            InitTable_GuildOther();
        return g_GuildOther;
    }
	
    public static bool InitTable_GuildOther()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_GuildOther.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_GuildOther.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_GuildOther.Validate(lines[1]))
			{
				g_GuildOther = new Dictionary<int, Tab_GuildOther>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_GuildOther(line);
						g_GuildOther[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_HeartAttr> g_HeartAttr;
	
    public static Tab_HeartAttr GetHeartAttrByID(int nKey, int nIndex = 0)
    {
        if(g_HeartAttr == null)
            InitTable_HeartAttr();
		Tab_HeartAttr result;
		g_HeartAttr.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_HeartAttr> GetHeartAttr()
    {
        if(g_HeartAttr == null)
            InitTable_HeartAttr();
        return g_HeartAttr;
    }
	
    public static bool InitTable_HeartAttr()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_HeartAttr.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_HeartAttr.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_HeartAttr.Validate(lines[1]))
			{
				g_HeartAttr = new Dictionary<int, Tab_HeartAttr>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_HeartAttr(line);
						g_HeartAttr[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_HeartBase> g_HeartBase;
	
    public static Tab_HeartBase GetHeartBaseByID(int nKey, int nIndex = 0)
    {
        if(g_HeartBase == null)
            InitTable_HeartBase();
		Tab_HeartBase result;
		g_HeartBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_HeartBase> GetHeartBase()
    {
        if(g_HeartBase == null)
            InitTable_HeartBase();
        return g_HeartBase;
    }
	
    public static bool InitTable_HeartBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_HeartBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_HeartBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_HeartBase.Validate(lines[1]))
			{
				g_HeartBase = new Dictionary<int, Tab_HeartBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_HeartBase(line);
						g_HeartBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_HeartClass> g_HeartClass;
	
    public static Tab_HeartClass GetHeartClassByID(int nKey, int nIndex = 0)
    {
        if(g_HeartClass == null)
            InitTable_HeartClass();
		Tab_HeartClass result;
		g_HeartClass.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_HeartClass> GetHeartClass()
    {
        if(g_HeartClass == null)
            InitTable_HeartClass();
        return g_HeartClass;
    }
	
    public static bool InitTable_HeartClass()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_HeartClass.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_HeartClass.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_HeartClass.Validate(lines[1]))
			{
				g_HeartClass = new Dictionary<int, Tab_HeartClass>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_HeartClass(line);
						g_HeartClass[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_HeartLevel> g_HeartLevel;
	
    public static Tab_HeartLevel GetHeartLevelByID(int nKey, int nIndex = 0)
    {
        if(g_HeartLevel == null)
            InitTable_HeartLevel();
		Tab_HeartLevel result;
		g_HeartLevel.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_HeartLevel> GetHeartLevel()
    {
        if(g_HeartLevel == null)
            InitTable_HeartLevel();
        return g_HeartLevel;
    }
	
    public static bool InitTable_HeartLevel()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_HeartLevel.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_HeartLevel.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_HeartLevel.Validate(lines[1]))
			{
				g_HeartLevel = new Dictionary<int, Tab_HeartLevel>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_HeartLevel(line);
						g_HeartLevel[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_HeartPulse> g_HeartPulse;
	
    public static Tab_HeartPulse GetHeartPulseByID(int nKey, int nIndex = 0)
    {
        if(g_HeartPulse == null)
            InitTable_HeartPulse();
		Tab_HeartPulse result;
		g_HeartPulse.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_HeartPulse> GetHeartPulse()
    {
        if(g_HeartPulse == null)
            InitTable_HeartPulse();
        return g_HeartPulse;
    }
	
    public static bool InitTable_HeartPulse()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_HeartPulse.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_HeartPulse.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_HeartPulse.Validate(lines[1]))
			{
				g_HeartPulse = new Dictionary<int, Tab_HeartPulse>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_HeartPulse(line);
						g_HeartPulse[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_HelpMessage> g_HelpMessage;
	
    public static Tab_HelpMessage GetHelpMessageByID(int nKey, int nIndex = 0)
    {
        if(g_HelpMessage == null)
            InitTable_HelpMessage();
		Tab_HelpMessage result;
		g_HelpMessage.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_HelpMessage> GetHelpMessage()
    {
        if(g_HelpMessage == null)
            InitTable_HelpMessage();
        return g_HelpMessage;
    }
	
    public static bool InitTable_HelpMessage()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_HelpMessage.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_HelpMessage.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_HelpMessage.Validate(lines[1]))
			{
				g_HelpMessage = new Dictionary<int, Tab_HelpMessage>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_HelpMessage(line);
						g_HelpMessage[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_HonorBattlefieldAwardDay> g_HonorBattlefieldAwardDay;
	
    public static Tab_HonorBattlefieldAwardDay GetHonorBattlefieldAwardDayByID(int nKey, int nIndex = 0)
    {
        if(g_HonorBattlefieldAwardDay == null)
            InitTable_HonorBattlefieldAwardDay();
		Tab_HonorBattlefieldAwardDay result;
		g_HonorBattlefieldAwardDay.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_HonorBattlefieldAwardDay> GetHonorBattlefieldAwardDay()
    {
        if(g_HonorBattlefieldAwardDay == null)
            InitTable_HonorBattlefieldAwardDay();
        return g_HonorBattlefieldAwardDay;
    }
	
    public static bool InitTable_HonorBattlefieldAwardDay()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_HonorBattlefieldAwardDay.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_HonorBattlefieldAwardDay.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_HonorBattlefieldAwardDay.Validate(lines[1]))
			{
				g_HonorBattlefieldAwardDay = new Dictionary<int, Tab_HonorBattlefieldAwardDay>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_HonorBattlefieldAwardDay(line);
						g_HonorBattlefieldAwardDay[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_HonorBattlefieldAwardR1ank> g_HonorBattlefieldAwardR1ank;
	
    public static Tab_HonorBattlefieldAwardR1ank GetHonorBattlefieldAwardR1ankByID(int nKey, int nIndex = 0)
    {
        if(g_HonorBattlefieldAwardR1ank == null)
            InitTable_HonorBattlefieldAwardR1ank();
		Tab_HonorBattlefieldAwardR1ank result;
		g_HonorBattlefieldAwardR1ank.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_HonorBattlefieldAwardR1ank> GetHonorBattlefieldAwardR1ank()
    {
        if(g_HonorBattlefieldAwardR1ank == null)
            InitTable_HonorBattlefieldAwardR1ank();
        return g_HonorBattlefieldAwardR1ank;
    }
	
    public static bool InitTable_HonorBattlefieldAwardR1ank()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_HonorBattlefieldAwardR1ank.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_HonorBattlefieldAwardR1ank.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_HonorBattlefieldAwardR1ank.Validate(lines[1]))
			{
				g_HonorBattlefieldAwardR1ank = new Dictionary<int, Tab_HonorBattlefieldAwardR1ank>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_HonorBattlefieldAwardR1ank(line);
						g_HonorBattlefieldAwardR1ank[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_HonorBattlefieldAwardRank> g_HonorBattlefieldAwardRank;
	
    public static Tab_HonorBattlefieldAwardRank GetHonorBattlefieldAwardRankByID(int nKey, int nIndex = 0)
    {
        if(g_HonorBattlefieldAwardRank == null)
            InitTable_HonorBattlefieldAwardRank();
		Tab_HonorBattlefieldAwardRank result;
		g_HonorBattlefieldAwardRank.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_HonorBattlefieldAwardRank> GetHonorBattlefieldAwardRank()
    {
        if(g_HonorBattlefieldAwardRank == null)
            InitTable_HonorBattlefieldAwardRank();
        return g_HonorBattlefieldAwardRank;
    }
	
    public static bool InitTable_HonorBattlefieldAwardRank()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_HonorBattlefieldAwardRank.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_HonorBattlefieldAwardRank.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_HonorBattlefieldAwardRank.Validate(lines[1]))
			{
				g_HonorBattlefieldAwardRank = new Dictionary<int, Tab_HonorBattlefieldAwardRank>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_HonorBattlefieldAwardRank(line);
						g_HonorBattlefieldAwardRank[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_HonorBattlefieldAwardSeason> g_HonorBattlefieldAwardSeason;
	
    public static Tab_HonorBattlefieldAwardSeason GetHonorBattlefieldAwardSeasonByID(int nKey, int nIndex = 0)
    {
        if(g_HonorBattlefieldAwardSeason == null)
            InitTable_HonorBattlefieldAwardSeason();
		Tab_HonorBattlefieldAwardSeason result;
		g_HonorBattlefieldAwardSeason.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_HonorBattlefieldAwardSeason> GetHonorBattlefieldAwardSeason()
    {
        if(g_HonorBattlefieldAwardSeason == null)
            InitTable_HonorBattlefieldAwardSeason();
        return g_HonorBattlefieldAwardSeason;
    }
	
    public static bool InitTable_HonorBattlefieldAwardSeason()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_HonorBattlefieldAwardSeason.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_HonorBattlefieldAwardSeason.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_HonorBattlefieldAwardSeason.Validate(lines[1]))
			{
				g_HonorBattlefieldAwardSeason = new Dictionary<int, Tab_HonorBattlefieldAwardSeason>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_HonorBattlefieldAwardSeason(line);
						g_HonorBattlefieldAwardSeason[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_HonorBattlefieldBase> g_HonorBattlefieldBase;
	
    public static Tab_HonorBattlefieldBase GetHonorBattlefieldBaseByID(int nKey, int nIndex = 0)
    {
        if(g_HonorBattlefieldBase == null)
            InitTable_HonorBattlefieldBase();
		Tab_HonorBattlefieldBase result;
		g_HonorBattlefieldBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_HonorBattlefieldBase> GetHonorBattlefieldBase()
    {
        if(g_HonorBattlefieldBase == null)
            InitTable_HonorBattlefieldBase();
        return g_HonorBattlefieldBase;
    }
	
    public static bool InitTable_HonorBattlefieldBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_HonorBattlefieldBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_HonorBattlefieldBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_HonorBattlefieldBase.Validate(lines[1]))
			{
				g_HonorBattlefieldBase = new Dictionary<int, Tab_HonorBattlefieldBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_HonorBattlefieldBase(line);
						g_HonorBattlefieldBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_HonorBattlefieldSegment> g_HonorBattlefieldSegment;
	
    public static Tab_HonorBattlefieldSegment GetHonorBattlefieldSegmentByID(int nKey, int nIndex = 0)
    {
        if(g_HonorBattlefieldSegment == null)
            InitTable_HonorBattlefieldSegment();
		Tab_HonorBattlefieldSegment result;
		g_HonorBattlefieldSegment.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_HonorBattlefieldSegment> GetHonorBattlefieldSegment()
    {
        if(g_HonorBattlefieldSegment == null)
            InitTable_HonorBattlefieldSegment();
        return g_HonorBattlefieldSegment;
    }
	
    public static bool InitTable_HonorBattlefieldSegment()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_HonorBattlefieldSegment.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_HonorBattlefieldSegment.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_HonorBattlefieldSegment.Validate(lines[1]))
			{
				g_HonorBattlefieldSegment = new Dictionary<int, Tab_HonorBattlefieldSegment>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_HonorBattlefieldSegment(line);
						g_HonorBattlefieldSegment[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Impact> g_Impact;
	
    public static Tab_Impact GetImpactByID(int nKey, int nIndex = 0)
    {
        if(g_Impact == null)
            InitTable_Impact();
		Tab_Impact result;
		g_Impact.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Impact> GetImpact()
    {
        if(g_Impact == null)
            InitTable_Impact();
        return g_Impact;
    }
	
    public static bool InitTable_Impact()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Impact.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Impact.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Impact.Validate(lines[1]))
			{
				g_Impact = new Dictionary<int, Tab_Impact>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Impact(line);
						g_Impact[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_InitFellowGrowth> g_InitFellowGrowth;
	
    public static Tab_InitFellowGrowth GetInitFellowGrowthByID(int nKey, int nIndex = 0)
    {
        if(g_InitFellowGrowth == null)
            InitTable_InitFellowGrowth();
		Tab_InitFellowGrowth result;
		g_InitFellowGrowth.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_InitFellowGrowth> GetInitFellowGrowth()
    {
        if(g_InitFellowGrowth == null)
            InitTable_InitFellowGrowth();
        return g_InitFellowGrowth;
    }
	
    public static bool InitTable_InitFellowGrowth()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_InitFellowGrowth.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_InitFellowGrowth.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_InitFellowGrowth.Validate(lines[1]))
			{
				g_InitFellowGrowth = new Dictionary<int, Tab_InitFellowGrowth>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_InitFellowGrowth(line);
						g_InitFellowGrowth[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_InteractionNode> g_InteractionNode;
	
    public static Tab_InteractionNode GetInteractionNodeByID(int nKey, int nIndex = 0)
    {
        if(g_InteractionNode == null)
            InitTable_InteractionNode();
		Tab_InteractionNode result;
		g_InteractionNode.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_InteractionNode> GetInteractionNode()
    {
        if(g_InteractionNode == null)
            InitTable_InteractionNode();
        return g_InteractionNode;
    }
	
    public static bool InitTable_InteractionNode()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_InteractionNode.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_InteractionNode.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_InteractionNode.Validate(lines[1]))
			{
				g_InteractionNode = new Dictionary<int, Tab_InteractionNode>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_InteractionNode(line);
						g_InteractionNode[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_InteractionSummary> g_InteractionSummary;
	
    public static Tab_InteractionSummary GetInteractionSummaryByID(int nKey, int nIndex = 0)
    {
        if(g_InteractionSummary == null)
            InitTable_InteractionSummary();
		Tab_InteractionSummary result;
		g_InteractionSummary.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_InteractionSummary> GetInteractionSummary()
    {
        if(g_InteractionSummary == null)
            InitTable_InteractionSummary();
        return g_InteractionSummary;
    }
	
    public static bool InitTable_InteractionSummary()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_InteractionSummary.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_InteractionSummary.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_InteractionSummary.Validate(lines[1]))
			{
				g_InteractionSummary = new Dictionary<int, Tab_InteractionSummary>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_InteractionSummary(line);
						g_InteractionSummary[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_ItemClassName>> g_ItemClassName;
	
	public static List<Tab_ItemClassName> GetItemClassNameByID(int nKey)
    {
        if(g_ItemClassName == null)
            InitTable_ItemClassName();
		List<Tab_ItemClassName> result;
		g_ItemClassName.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_ItemClassName GetItemClassNameByID(int nKey, int nIndex)
    {
        if(g_ItemClassName == null)
            InitTable_ItemClassName();
		List<Tab_ItemClassName> list;
		Tab_ItemClassName result = null;
		if (nIndex >= 0 &&
			g_ItemClassName.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_ItemClassName>> GetItemClassName()
    {
        if(g_ItemClassName == null)
            InitTable_ItemClassName();
        return g_ItemClassName;
    }
	
	public static bool InitTable_ItemClassName()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ItemClassName.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ItemClassName.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ItemClassName.Validate(lines[1]))
			{
				g_ItemClassName = new Dictionary<int, List<Tab_ItemClassName>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ItemClassName(line);
						List<Tab_ItemClassName> list;
						var id = item.GetId();
						if (!g_ItemClassName.TryGetValue(id, out list))
						{
							list = new List<Tab_ItemClassName>();
							g_ItemClassName.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ItemCombine> g_ItemCombine;
	
    public static Tab_ItemCombine GetItemCombineByID(int nKey, int nIndex = 0)
    {
        if(g_ItemCombine == null)
            InitTable_ItemCombine();
		Tab_ItemCombine result;
		g_ItemCombine.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ItemCombine> GetItemCombine()
    {
        if(g_ItemCombine == null)
            InitTable_ItemCombine();
        return g_ItemCombine;
    }
	
    public static bool InitTable_ItemCombine()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ItemCombine.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ItemCombine.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ItemCombine.Validate(lines[1]))
			{
				g_ItemCombine = new Dictionary<int, Tab_ItemCombine>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ItemCombine(line);
						g_ItemCombine[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ItemDecomposition> g_ItemDecomposition;
	
    public static Tab_ItemDecomposition GetItemDecompositionByID(int nKey, int nIndex = 0)
    {
        if(g_ItemDecomposition == null)
            InitTable_ItemDecomposition();
		Tab_ItemDecomposition result;
		g_ItemDecomposition.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ItemDecomposition> GetItemDecomposition()
    {
        if(g_ItemDecomposition == null)
            InitTable_ItemDecomposition();
        return g_ItemDecomposition;
    }
	
    public static bool InitTable_ItemDecomposition()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ItemDecomposition.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ItemDecomposition.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ItemDecomposition.Validate(lines[1]))
			{
				g_ItemDecomposition = new Dictionary<int, Tab_ItemDecomposition>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ItemDecomposition(line);
						g_ItemDecomposition[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_ItemGetPath>> g_ItemGetPath;
	
	public static List<Tab_ItemGetPath> GetItemGetPathByID(int nKey)
    {
        if(g_ItemGetPath == null)
            InitTable_ItemGetPath();
		List<Tab_ItemGetPath> result;
		g_ItemGetPath.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_ItemGetPath GetItemGetPathByID(int nKey, int nIndex)
    {
        if(g_ItemGetPath == null)
            InitTable_ItemGetPath();
		List<Tab_ItemGetPath> list;
		Tab_ItemGetPath result = null;
		if (nIndex >= 0 &&
			g_ItemGetPath.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_ItemGetPath>> GetItemGetPath()
    {
        if(g_ItemGetPath == null)
            InitTable_ItemGetPath();
        return g_ItemGetPath;
    }
	
	public static bool InitTable_ItemGetPath()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ItemGetPath.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ItemGetPath.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ItemGetPath.Validate(lines[1]))
			{
				g_ItemGetPath = new Dictionary<int, List<Tab_ItemGetPath>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ItemGetPath(line);
						List<Tab_ItemGetPath> list;
						var id = item.GetId();
						if (!g_ItemGetPath.TryGetValue(id, out list))
						{
							list = new List<Tab_ItemGetPath>();
							g_ItemGetPath.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ItemSameUse> g_ItemSameUse;
	
    public static Tab_ItemSameUse GetItemSameUseByID(int nKey, int nIndex = 0)
    {
        if(g_ItemSameUse == null)
            InitTable_ItemSameUse();
		Tab_ItemSameUse result;
		g_ItemSameUse.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ItemSameUse> GetItemSameUse()
    {
        if(g_ItemSameUse == null)
            InitTable_ItemSameUse();
        return g_ItemSameUse;
    }
	
    public static bool InitTable_ItemSameUse()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ItemSameUse.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ItemSameUse.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ItemSameUse.Validate(lines[1]))
			{
				g_ItemSameUse = new Dictionary<int, Tab_ItemSameUse>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ItemSameUse(line);
						g_ItemSameUse[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ItemVisual> g_ItemVisual;
	
    public static Tab_ItemVisual GetItemVisualByID(int nKey, int nIndex = 0)
    {
        if(g_ItemVisual == null)
            InitTable_ItemVisual();
		Tab_ItemVisual result;
		g_ItemVisual.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ItemVisual> GetItemVisual()
    {
        if(g_ItemVisual == null)
            InitTable_ItemVisual();
        return g_ItemVisual;
    }
	
    public static bool InitTable_ItemVisual()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ItemVisual.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ItemVisual.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ItemVisual.Validate(lines[1]))
			{
				g_ItemVisual = new Dictionary<int, Tab_ItemVisual>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ItemVisual(line);
						g_ItemVisual[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Jump> g_Jump;
	
    public static Tab_Jump GetJumpByID(int nKey, int nIndex = 0)
    {
        if(g_Jump == null)
            InitTable_Jump();
		Tab_Jump result;
		g_Jump.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Jump> GetJump()
    {
        if(g_Jump == null)
            InitTable_Jump();
        return g_Jump;
    }
	
    public static bool InitTable_Jump()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Jump.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Jump.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Jump.Validate(lines[1]))
			{
				g_Jump = new Dictionary<int, Tab_Jump>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Jump(line);
						g_Jump[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_LevelCombatTipItem> g_LevelCombatTipItem;
	
    public static Tab_LevelCombatTipItem GetLevelCombatTipItemByID(int nKey, int nIndex = 0)
    {
        if(g_LevelCombatTipItem == null)
            InitTable_LevelCombatTipItem();
		Tab_LevelCombatTipItem result;
		g_LevelCombatTipItem.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_LevelCombatTipItem> GetLevelCombatTipItem()
    {
        if(g_LevelCombatTipItem == null)
            InitTable_LevelCombatTipItem();
        return g_LevelCombatTipItem;
    }
	
    public static bool InitTable_LevelCombatTipItem()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_LevelCombatTipItem.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_LevelCombatTipItem.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_LevelCombatTipItem.Validate(lines[1]))
			{
				g_LevelCombatTipItem = new Dictionary<int, Tab_LevelCombatTipItem>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_LevelCombatTipItem(line);
						g_LevelCombatTipItem[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_LevelTip> g_LevelTip;
	
    public static Tab_LevelTip GetLevelTipByID(int nKey, int nIndex = 0)
    {
        if(g_LevelTip == null)
            InitTable_LevelTip();
		Tab_LevelTip result;
		g_LevelTip.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_LevelTip> GetLevelTip()
    {
        if(g_LevelTip == null)
            InitTable_LevelTip();
        return g_LevelTip;
    }
	
    public static bool InitTable_LevelTip()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_LevelTip.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_LevelTip.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_LevelTip.Validate(lines[1]))
			{
				g_LevelTip = new Dictionary<int, Tab_LevelTip>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_LevelTip(line);
						g_LevelTip[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_LevelUp> g_LevelUp;
	
    public static Tab_LevelUp GetLevelUpByID(int nKey, int nIndex = 0)
    {
        if(g_LevelUp == null)
            InitTable_LevelUp();
		Tab_LevelUp result;
		g_LevelUp.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_LevelUp> GetLevelUp()
    {
        if(g_LevelUp == null)
            InitTable_LevelUp();
        return g_LevelUp;
    }
	
    public static bool InitTable_LevelUp()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_LevelUp.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_LevelUp.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_LevelUp.Validate(lines[1]))
			{
				g_LevelUp = new Dictionary<int, Tab_LevelUp>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_LevelUp(line);
						g_LevelUp[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_LivingSkillItem> g_LivingSkillItem;
	
    public static Tab_LivingSkillItem GetLivingSkillItemByID(int nKey, int nIndex = 0)
    {
        if(g_LivingSkillItem == null)
            InitTable_LivingSkillItem();
		Tab_LivingSkillItem result;
		g_LivingSkillItem.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_LivingSkillItem> GetLivingSkillItem()
    {
        if(g_LivingSkillItem == null)
            InitTable_LivingSkillItem();
        return g_LivingSkillItem;
    }
	
    public static bool InitTable_LivingSkillItem()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_LivingSkillItem.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_LivingSkillItem.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_LivingSkillItem.Validate(lines[1]))
			{
				g_LivingSkillItem = new Dictionary<int, Tab_LivingSkillItem>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_LivingSkillItem(line);
						g_LivingSkillItem[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_LivingSkills> g_LivingSkills;
	
    public static Tab_LivingSkills GetLivingSkillsByID(int nKey, int nIndex = 0)
    {
        if(g_LivingSkills == null)
            InitTable_LivingSkills();
		Tab_LivingSkills result;
		g_LivingSkills.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_LivingSkills> GetLivingSkills()
    {
        if(g_LivingSkills == null)
            InitTable_LivingSkills();
        return g_LivingSkills;
    }
	
    public static bool InitTable_LivingSkills()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_LivingSkills.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_LivingSkills.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_LivingSkills.Validate(lines[1]))
			{
				g_LivingSkills = new Dictionary<int, Tab_LivingSkills>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_LivingSkills(line);
						g_LivingSkills[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_LoadingTips> g_LoadingTips;
	
    public static Tab_LoadingTips GetLoadingTipsByID(int nKey, int nIndex = 0)
    {
        if(g_LoadingTips == null)
            InitTable_LoadingTips();
		Tab_LoadingTips result;
		g_LoadingTips.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_LoadingTips> GetLoadingTips()
    {
        if(g_LoadingTips == null)
            InitTable_LoadingTips();
        return g_LoadingTips;
    }
	
    public static bool InitTable_LoadingTips()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_LoadingTips.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_LoadingTips.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_LoadingTips.Validate(lines[1]))
			{
				g_LoadingTips = new Dictionary<int, Tab_LoadingTips>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_LoadingTips(line);
						g_LoadingTips[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MagicWeaponActiveModel> g_MagicWeaponActiveModel;
	
    public static Tab_MagicWeaponActiveModel GetMagicWeaponActiveModelByID(int nKey, int nIndex = 0)
    {
        if(g_MagicWeaponActiveModel == null)
            InitTable_MagicWeaponActiveModel();
		Tab_MagicWeaponActiveModel result;
		g_MagicWeaponActiveModel.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MagicWeaponActiveModel> GetMagicWeaponActiveModel()
    {
        if(g_MagicWeaponActiveModel == null)
            InitTable_MagicWeaponActiveModel();
        return g_MagicWeaponActiveModel;
    }
	
    public static bool InitTable_MagicWeaponActiveModel()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MagicWeaponActiveModel.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MagicWeaponActiveModel.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MagicWeaponActiveModel.Validate(lines[1]))
			{
				g_MagicWeaponActiveModel = new Dictionary<int, Tab_MagicWeaponActiveModel>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MagicWeaponActiveModel(line);
						g_MagicWeaponActiveModel[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MagicWeaponBaseAttr> g_MagicWeaponBaseAttr;
	
    public static Tab_MagicWeaponBaseAttr GetMagicWeaponBaseAttrByID(int nKey, int nIndex = 0)
    {
        if(g_MagicWeaponBaseAttr == null)
            InitTable_MagicWeaponBaseAttr();
		Tab_MagicWeaponBaseAttr result;
		g_MagicWeaponBaseAttr.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MagicWeaponBaseAttr> GetMagicWeaponBaseAttr()
    {
        if(g_MagicWeaponBaseAttr == null)
            InitTable_MagicWeaponBaseAttr();
        return g_MagicWeaponBaseAttr;
    }
	
    public static bool InitTable_MagicWeaponBaseAttr()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MagicWeaponBaseAttr.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MagicWeaponBaseAttr.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MagicWeaponBaseAttr.Validate(lines[1]))
			{
				g_MagicWeaponBaseAttr = new Dictionary<int, Tab_MagicWeaponBaseAttr>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MagicWeaponBaseAttr(line);
						g_MagicWeaponBaseAttr[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MagicWeaponDressAttr> g_MagicWeaponDressAttr;
	
    public static Tab_MagicWeaponDressAttr GetMagicWeaponDressAttrByID(int nKey, int nIndex = 0)
    {
        if(g_MagicWeaponDressAttr == null)
            InitTable_MagicWeaponDressAttr();
		Tab_MagicWeaponDressAttr result;
		g_MagicWeaponDressAttr.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MagicWeaponDressAttr> GetMagicWeaponDressAttr()
    {
        if(g_MagicWeaponDressAttr == null)
            InitTable_MagicWeaponDressAttr();
        return g_MagicWeaponDressAttr;
    }
	
    public static bool InitTable_MagicWeaponDressAttr()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MagicWeaponDressAttr.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MagicWeaponDressAttr.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MagicWeaponDressAttr.Validate(lines[1]))
			{
				g_MagicWeaponDressAttr = new Dictionary<int, Tab_MagicWeaponDressAttr>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MagicWeaponDressAttr(line);
						g_MagicWeaponDressAttr[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MagicWeaponRandCost> g_MagicWeaponRandCost;
	
    public static Tab_MagicWeaponRandCost GetMagicWeaponRandCostByID(int nKey, int nIndex = 0)
    {
        if(g_MagicWeaponRandCost == null)
            InitTable_MagicWeaponRandCost();
		Tab_MagicWeaponRandCost result;
		g_MagicWeaponRandCost.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MagicWeaponRandCost> GetMagicWeaponRandCost()
    {
        if(g_MagicWeaponRandCost == null)
            InitTable_MagicWeaponRandCost();
        return g_MagicWeaponRandCost;
    }
	
    public static bool InitTable_MagicWeaponRandCost()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MagicWeaponRandCost.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MagicWeaponRandCost.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MagicWeaponRandCost.Validate(lines[1]))
			{
				g_MagicWeaponRandCost = new Dictionary<int, Tab_MagicWeaponRandCost>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MagicWeaponRandCost(line);
						g_MagicWeaponRandCost[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MagicWeaponUpgrade> g_MagicWeaponUpgrade;
	
    public static Tab_MagicWeaponUpgrade GetMagicWeaponUpgradeByID(int nKey, int nIndex = 0)
    {
        if(g_MagicWeaponUpgrade == null)
            InitTable_MagicWeaponUpgrade();
		Tab_MagicWeaponUpgrade result;
		g_MagicWeaponUpgrade.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MagicWeaponUpgrade> GetMagicWeaponUpgrade()
    {
        if(g_MagicWeaponUpgrade == null)
            InitTable_MagicWeaponUpgrade();
        return g_MagicWeaponUpgrade;
    }
	
    public static bool InitTable_MagicWeaponUpgrade()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MagicWeaponUpgrade.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MagicWeaponUpgrade.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MagicWeaponUpgrade.Validate(lines[1]))
			{
				g_MagicWeaponUpgrade = new Dictionary<int, Tab_MagicWeaponUpgrade>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MagicWeaponUpgrade(line);
						g_MagicWeaponUpgrade[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_MapConnection>> g_MapConnection;
	
	public static List<Tab_MapConnection> GetMapConnectionByID(int nKey)
    {
        if(g_MapConnection == null)
            InitTable_MapConnection();
		List<Tab_MapConnection> result;
		g_MapConnection.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_MapConnection GetMapConnectionByID(int nKey, int nIndex)
    {
        if(g_MapConnection == null)
            InitTable_MapConnection();
		List<Tab_MapConnection> list;
		Tab_MapConnection result = null;
		if (nIndex >= 0 &&
			g_MapConnection.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_MapConnection>> GetMapConnection()
    {
        if(g_MapConnection == null)
            InitTable_MapConnection();
        return g_MapConnection;
    }
	
	public static bool InitTable_MapConnection()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MapConnection.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MapConnection.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MapConnection.Validate(lines[1]))
			{
				g_MapConnection = new Dictionary<int, List<Tab_MapConnection>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MapConnection(line);
						List<Tab_MapConnection> list;
						var id = item.GetId();
						if (!g_MapConnection.TryGetValue(id, out list))
						{
							list = new List<Tab_MapConnection>();
							g_MapConnection.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_MarketFilterLevel>> g_MarketFilterLevel;
	
	public static List<Tab_MarketFilterLevel> GetMarketFilterLevelByID(int nKey)
    {
        if(g_MarketFilterLevel == null)
            InitTable_MarketFilterLevel();
		List<Tab_MarketFilterLevel> result;
		g_MarketFilterLevel.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_MarketFilterLevel GetMarketFilterLevelByID(int nKey, int nIndex)
    {
        if(g_MarketFilterLevel == null)
            InitTable_MarketFilterLevel();
		List<Tab_MarketFilterLevel> list;
		Tab_MarketFilterLevel result = null;
		if (nIndex >= 0 &&
			g_MarketFilterLevel.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_MarketFilterLevel>> GetMarketFilterLevel()
    {
        if(g_MarketFilterLevel == null)
            InitTable_MarketFilterLevel();
        return g_MarketFilterLevel;
    }
	
	public static bool InitTable_MarketFilterLevel()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MarketFilterLevel.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MarketFilterLevel.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MarketFilterLevel.Validate(lines[1]))
			{
				g_MarketFilterLevel = new Dictionary<int, List<Tab_MarketFilterLevel>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MarketFilterLevel(line);
						List<Tab_MarketFilterLevel> list;
						var id = item.GetId();
						if (!g_MarketFilterLevel.TryGetValue(id, out list))
						{
							list = new List<Tab_MarketFilterLevel>();
							g_MarketFilterLevel.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MarryBase> g_MarryBase;
	
    public static Tab_MarryBase GetMarryBaseByID(int nKey, int nIndex = 0)
    {
        if(g_MarryBase == null)
            InitTable_MarryBase();
		Tab_MarryBase result;
		g_MarryBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MarryBase> GetMarryBase()
    {
        if(g_MarryBase == null)
            InitTable_MarryBase();
        return g_MarryBase;
    }
	
    public static bool InitTable_MarryBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MarryBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MarryBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MarryBase.Validate(lines[1]))
			{
				g_MarryBase = new Dictionary<int, Tab_MarryBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MarryBase(line);
						g_MarryBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MarryFetter> g_MarryFetter;
	
    public static Tab_MarryFetter GetMarryFetterByID(int nKey, int nIndex = 0)
    {
        if(g_MarryFetter == null)
            InitTable_MarryFetter();
		Tab_MarryFetter result;
		g_MarryFetter.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MarryFetter> GetMarryFetter()
    {
        if(g_MarryFetter == null)
            InitTable_MarryFetter();
        return g_MarryFetter;
    }
	
    public static bool InitTable_MarryFetter()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MarryFetter.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MarryFetter.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MarryFetter.Validate(lines[1]))
			{
				g_MarryFetter = new Dictionary<int, Tab_MarryFetter>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MarryFetter(line);
						g_MarryFetter[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MarryRingBase> g_MarryRingBase;
	
    public static Tab_MarryRingBase GetMarryRingBaseByID(int nKey, int nIndex = 0)
    {
        if(g_MarryRingBase == null)
            InitTable_MarryRingBase();
		Tab_MarryRingBase result;
		g_MarryRingBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MarryRingBase> GetMarryRingBase()
    {
        if(g_MarryRingBase == null)
            InitTable_MarryRingBase();
        return g_MarryRingBase;
    }
	
    public static bool InitTable_MarryRingBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MarryRingBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MarryRingBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MarryRingBase.Validate(lines[1]))
			{
				g_MarryRingBase = new Dictionary<int, Tab_MarryRingBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MarryRingBase(line);
						g_MarryRingBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MarryRingSkillBase> g_MarryRingSkillBase;
	
    public static Tab_MarryRingSkillBase GetMarryRingSkillBaseByID(int nKey, int nIndex = 0)
    {
        if(g_MarryRingSkillBase == null)
            InitTable_MarryRingSkillBase();
		Tab_MarryRingSkillBase result;
		g_MarryRingSkillBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MarryRingSkillBase> GetMarryRingSkillBase()
    {
        if(g_MarryRingSkillBase == null)
            InitTable_MarryRingSkillBase();
        return g_MarryRingSkillBase;
    }
	
    public static bool InitTable_MarryRingSkillBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MarryRingSkillBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MarryRingSkillBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MarryRingSkillBase.Validate(lines[1]))
			{
				g_MarryRingSkillBase = new Dictionary<int, Tab_MarryRingSkillBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MarryRingSkillBase(line);
						g_MarryRingSkillBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MarryStarBase> g_MarryStarBase;
	
    public static Tab_MarryStarBase GetMarryStarBaseByID(int nKey, int nIndex = 0)
    {
        if(g_MarryStarBase == null)
            InitTable_MarryStarBase();
		Tab_MarryStarBase result;
		g_MarryStarBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MarryStarBase> GetMarryStarBase()
    {
        if(g_MarryStarBase == null)
            InitTable_MarryStarBase();
        return g_MarryStarBase;
    }
	
    public static bool InitTable_MarryStarBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MarryStarBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MarryStarBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MarryStarBase.Validate(lines[1]))
			{
				g_MarryStarBase = new Dictionary<int, Tab_MarryStarBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MarryStarBase(line);
						g_MarryStarBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionBase> g_MissionBase;
	
    public static Tab_MissionBase GetMissionBaseByID(int nKey, int nIndex = 0)
    {
        if(g_MissionBase == null)
            InitTable_MissionBase();
		Tab_MissionBase result;
		g_MissionBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionBase> GetMissionBase()
    {
        if(g_MissionBase == null)
            InitTable_MissionBase();
        return g_MissionBase;
    }
	
    public static bool InitTable_MissionBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionBase.Validate(lines[1]))
			{
				g_MissionBase = new Dictionary<int, Tab_MissionBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionBase(line);
						g_MissionBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionBattleField> g_MissionBattleField;
	
    public static Tab_MissionBattleField GetMissionBattleFieldByID(int nKey, int nIndex = 0)
    {
        if(g_MissionBattleField == null)
            InitTable_MissionBattleField();
		Tab_MissionBattleField result;
		g_MissionBattleField.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionBattleField> GetMissionBattleField()
    {
        if(g_MissionBattleField == null)
            InitTable_MissionBattleField();
        return g_MissionBattleField;
    }
	
    public static bool InitTable_MissionBattleField()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionBattleField.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionBattleField.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionBattleField.Validate(lines[1]))
			{
				g_MissionBattleField = new Dictionary<int, Tab_MissionBattleField>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionBattleField(line);
						g_MissionBattleField[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionBonus> g_MissionBonus;
	
    public static Tab_MissionBonus GetMissionBonusByID(int nKey, int nIndex = 0)
    {
        if(g_MissionBonus == null)
            InitTable_MissionBonus();
		Tab_MissionBonus result;
		g_MissionBonus.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionBonus> GetMissionBonus()
    {
        if(g_MissionBonus == null)
            InitTable_MissionBonus();
        return g_MissionBonus;
    }
	
    public static bool InitTable_MissionBonus()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionBonus.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionBonus.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionBonus.Validate(lines[1]))
			{
				g_MissionBonus = new Dictionary<int, Tab_MissionBonus>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionBonus(line);
						g_MissionBonus[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionBranch> g_MissionBranch;
	
    public static Tab_MissionBranch GetMissionBranchByID(int nKey, int nIndex = 0)
    {
        if(g_MissionBranch == null)
            InitTable_MissionBranch();
		Tab_MissionBranch result;
		g_MissionBranch.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionBranch> GetMissionBranch()
    {
        if(g_MissionBranch == null)
            InitTable_MissionBranch();
        return g_MissionBranch;
    }
	
    public static bool InitTable_MissionBranch()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionBranch.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionBranch.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionBranch.Validate(lines[1]))
			{
				g_MissionBranch = new Dictionary<int, Tab_MissionBranch>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionBranch(line);
						g_MissionBranch[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionCollectItem> g_MissionCollectItem;
	
    public static Tab_MissionCollectItem GetMissionCollectItemByID(int nKey, int nIndex = 0)
    {
        if(g_MissionCollectItem == null)
            InitTable_MissionCollectItem();
		Tab_MissionCollectItem result;
		g_MissionCollectItem.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionCollectItem> GetMissionCollectItem()
    {
        if(g_MissionCollectItem == null)
            InitTable_MissionCollectItem();
        return g_MissionCollectItem;
    }
	
    public static bool InitTable_MissionCollectItem()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionCollectItem.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionCollectItem.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionCollectItem.Validate(lines[1]))
			{
				g_MissionCollectItem = new Dictionary<int, Tab_MissionCollectItem>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionCollectItem(line);
						g_MissionCollectItem[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionCopyScene> g_MissionCopyScene;
	
    public static Tab_MissionCopyScene GetMissionCopySceneByID(int nKey, int nIndex = 0)
    {
        if(g_MissionCopyScene == null)
            InitTable_MissionCopyScene();
		Tab_MissionCopyScene result;
		g_MissionCopyScene.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionCopyScene> GetMissionCopyScene()
    {
        if(g_MissionCopyScene == null)
            InitTable_MissionCopyScene();
        return g_MissionCopyScene;
    }
	
    public static bool InitTable_MissionCopyScene()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionCopyScene.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionCopyScene.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionCopyScene.Validate(lines[1]))
			{
				g_MissionCopyScene = new Dictionary<int, Tab_MissionCopyScene>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionCopyScene(line);
						g_MissionCopyScene[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionDelivery> g_MissionDelivery;
	
    public static Tab_MissionDelivery GetMissionDeliveryByID(int nKey, int nIndex = 0)
    {
        if(g_MissionDelivery == null)
            InitTable_MissionDelivery();
		Tab_MissionDelivery result;
		g_MissionDelivery.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionDelivery> GetMissionDelivery()
    {
        if(g_MissionDelivery == null)
            InitTable_MissionDelivery();
        return g_MissionDelivery;
    }
	
    public static bool InitTable_MissionDelivery()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionDelivery.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionDelivery.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionDelivery.Validate(lines[1]))
			{
				g_MissionDelivery = new Dictionary<int, Tab_MissionDelivery>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionDelivery(line);
						g_MissionDelivery[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionDialog> g_MissionDialog;
	
    public static Tab_MissionDialog GetMissionDialogByID(int nKey, int nIndex = 0)
    {
        if(g_MissionDialog == null)
            InitTable_MissionDialog();
		Tab_MissionDialog result;
		g_MissionDialog.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionDialog> GetMissionDialog()
    {
        if(g_MissionDialog == null)
            InitTable_MissionDialog();
        return g_MissionDialog;
    }
	
    public static bool InitTable_MissionDialog()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionDialog.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionDialog.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionDialog.Validate(lines[1]))
			{
				g_MissionDialog = new Dictionary<int, Tab_MissionDialog>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionDialog(line);
						g_MissionDialog[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionDictionary> g_MissionDictionary;
	
    public static Tab_MissionDictionary GetMissionDictionaryByID(int nKey, int nIndex = 0)
    {
        if(g_MissionDictionary == null)
            InitTable_MissionDictionary();
		Tab_MissionDictionary result;
		g_MissionDictionary.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionDictionary> GetMissionDictionary()
    {
        if(g_MissionDictionary == null)
            InitTable_MissionDictionary();
        return g_MissionDictionary;
    }
	
    public static bool InitTable_MissionDictionary()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionDictionary.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionDictionary.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionDictionary.Validate(lines[1]))
			{
				g_MissionDictionary = new Dictionary<int, Tab_MissionDictionary>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionDictionary(line);
						g_MissionDictionary[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionEnterArea> g_MissionEnterArea;
	
    public static Tab_MissionEnterArea GetMissionEnterAreaByID(int nKey, int nIndex = 0)
    {
        if(g_MissionEnterArea == null)
            InitTable_MissionEnterArea();
		Tab_MissionEnterArea result;
		g_MissionEnterArea.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionEnterArea> GetMissionEnterArea()
    {
        if(g_MissionEnterArea == null)
            InitTable_MissionEnterArea();
        return g_MissionEnterArea;
    }
	
    public static bool InitTable_MissionEnterArea()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionEnterArea.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionEnterArea.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionEnterArea.Validate(lines[1]))
			{
				g_MissionEnterArea = new Dictionary<int, Tab_MissionEnterArea>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionEnterArea(line);
						g_MissionEnterArea[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_MissionGroup>> g_MissionGroup;
	
	public static List<Tab_MissionGroup> GetMissionGroupByID(int nKey)
    {
        if(g_MissionGroup == null)
            InitTable_MissionGroup();
		List<Tab_MissionGroup> result;
		g_MissionGroup.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_MissionGroup GetMissionGroupByID(int nKey, int nIndex)
    {
        if(g_MissionGroup == null)
            InitTable_MissionGroup();
		List<Tab_MissionGroup> list;
		Tab_MissionGroup result = null;
		if (nIndex >= 0 &&
			g_MissionGroup.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_MissionGroup>> GetMissionGroup()
    {
        if(g_MissionGroup == null)
            InitTable_MissionGroup();
        return g_MissionGroup;
    }
	
	public static bool InitTable_MissionGroup()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionGroup.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionGroup.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionGroup.Validate(lines[1]))
			{
				g_MissionGroup = new Dictionary<int, List<Tab_MissionGroup>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionGroup(line);
						List<Tab_MissionGroup> list;
						var id = item.GetId();
						if (!g_MissionGroup.TryGetValue(id, out list))
						{
							list = new List<Tab_MissionGroup>();
							g_MissionGroup.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionGuidBase> g_MissionGuidBase;
	
    public static Tab_MissionGuidBase GetMissionGuidBaseByID(int nKey, int nIndex = 0)
    {
        if(g_MissionGuidBase == null)
            InitTable_MissionGuidBase();
		Tab_MissionGuidBase result;
		g_MissionGuidBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionGuidBase> GetMissionGuidBase()
    {
        if(g_MissionGuidBase == null)
            InitTable_MissionGuidBase();
        return g_MissionGuidBase;
    }
	
    public static bool InitTable_MissionGuidBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionGuidBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionGuidBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionGuidBase.Validate(lines[1]))
			{
				g_MissionGuidBase = new Dictionary<int, Tab_MissionGuidBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionGuidBase(line);
						g_MissionGuidBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionInTime> g_MissionInTime;
	
    public static Tab_MissionInTime GetMissionInTimeByID(int nKey, int nIndex = 0)
    {
        if(g_MissionInTime == null)
            InitTable_MissionInTime();
		Tab_MissionInTime result;
		g_MissionInTime.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionInTime> GetMissionInTime()
    {
        if(g_MissionInTime == null)
            InitTable_MissionInTime();
        return g_MissionInTime;
    }
	
    public static bool InitTable_MissionInTime()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionInTime.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionInTime.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionInTime.Validate(lines[1]))
			{
				g_MissionInTime = new Dictionary<int, Tab_MissionInTime>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionInTime(line);
						g_MissionInTime[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionItemGetPath> g_MissionItemGetPath;
	
    public static Tab_MissionItemGetPath GetMissionItemGetPathByID(int nKey, int nIndex = 0)
    {
        if(g_MissionItemGetPath == null)
            InitTable_MissionItemGetPath();
		Tab_MissionItemGetPath result;
		g_MissionItemGetPath.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionItemGetPath> GetMissionItemGetPath()
    {
        if(g_MissionItemGetPath == null)
            InitTable_MissionItemGetPath();
        return g_MissionItemGetPath;
    }
	
    public static bool InitTable_MissionItemGetPath()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionItemGetPath.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionItemGetPath.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionItemGetPath.Validate(lines[1]))
			{
				g_MissionItemGetPath = new Dictionary<int, Tab_MissionItemGetPath>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionItemGetPath(line);
						g_MissionItemGetPath[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionKillMonster> g_MissionKillMonster;
	
    public static Tab_MissionKillMonster GetMissionKillMonsterByID(int nKey, int nIndex = 0)
    {
        if(g_MissionKillMonster == null)
            InitTable_MissionKillMonster();
		Tab_MissionKillMonster result;
		g_MissionKillMonster.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionKillMonster> GetMissionKillMonster()
    {
        if(g_MissionKillMonster == null)
            InitTable_MissionKillMonster();
        return g_MissionKillMonster;
    }
	
    public static bool InitTable_MissionKillMonster()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionKillMonster.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionKillMonster.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionKillMonster.Validate(lines[1]))
			{
				g_MissionKillMonster = new Dictionary<int, Tab_MissionKillMonster>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionKillMonster(line);
						g_MissionKillMonster[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionLevelUp> g_MissionLevelUp;
	
    public static Tab_MissionLevelUp GetMissionLevelUpByID(int nKey, int nIndex = 0)
    {
        if(g_MissionLevelUp == null)
            InitTable_MissionLevelUp();
		Tab_MissionLevelUp result;
		g_MissionLevelUp.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionLevelUp> GetMissionLevelUp()
    {
        if(g_MissionLevelUp == null)
            InitTable_MissionLevelUp();
        return g_MissionLevelUp;
    }
	
    public static bool InitTable_MissionLevelUp()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionLevelUp.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionLevelUp.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionLevelUp.Validate(lines[1]))
			{
				g_MissionLevelUp = new Dictionary<int, Tab_MissionLevelUp>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionLevelUp(line);
						g_MissionLevelUp[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionLimit> g_MissionLimit;
	
    public static Tab_MissionLimit GetMissionLimitByID(int nKey, int nIndex = 0)
    {
        if(g_MissionLimit == null)
            InitTable_MissionLimit();
		Tab_MissionLimit result;
		g_MissionLimit.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionLimit> GetMissionLimit()
    {
        if(g_MissionLimit == null)
            InitTable_MissionLimit();
        return g_MissionLimit;
    }
	
    public static bool InitTable_MissionLimit()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionLimit.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionLimit.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionLimit.Validate(lines[1]))
			{
				g_MissionLimit = new Dictionary<int, Tab_MissionLimit>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionLimit(line);
						g_MissionLimit[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionLogic> g_MissionLogic;
	
    public static Tab_MissionLogic GetMissionLogicByID(int nKey, int nIndex = 0)
    {
        if(g_MissionLogic == null)
            InitTable_MissionLogic();
		Tab_MissionLogic result;
		g_MissionLogic.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionLogic> GetMissionLogic()
    {
        if(g_MissionLogic == null)
            InitTable_MissionLogic();
        return g_MissionLogic;
    }
	
    public static bool InitTable_MissionLogic()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionLogic.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionLogic.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionLogic.Validate(lines[1]))
			{
				g_MissionLogic = new Dictionary<int, Tab_MissionLogic>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionLogic(line);
						g_MissionLogic[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionLootItem> g_MissionLootItem;
	
    public static Tab_MissionLootItem GetMissionLootItemByID(int nKey, int nIndex = 0)
    {
        if(g_MissionLootItem == null)
            InitTable_MissionLootItem();
		Tab_MissionLootItem result;
		g_MissionLootItem.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionLootItem> GetMissionLootItem()
    {
        if(g_MissionLootItem == null)
            InitTable_MissionLootItem();
        return g_MissionLootItem;
    }
	
    public static bool InitTable_MissionLootItem()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionLootItem.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionLootItem.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionLootItem.Validate(lines[1]))
			{
				g_MissionLootItem = new Dictionary<int, Tab_MissionLootItem>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionLootItem(line);
						g_MissionLootItem[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionNext> g_MissionNext;
	
    public static Tab_MissionNext GetMissionNextByID(int nKey, int nIndex = 0)
    {
        if(g_MissionNext == null)
            InitTable_MissionNext();
		Tab_MissionNext result;
		g_MissionNext.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionNext> GetMissionNext()
    {
        if(g_MissionNext == null)
            InitTable_MissionNext();
        return g_MissionNext;
    }
	
    public static bool InitTable_MissionNext()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionNext.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionNext.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionNext.Validate(lines[1]))
			{
				g_MissionNext = new Dictionary<int, Tab_MissionNext>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionNext(line);
						g_MissionNext[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionOneDragon> g_MissionOneDragon;
	
    public static Tab_MissionOneDragon GetMissionOneDragonByID(int nKey, int nIndex = 0)
    {
        if(g_MissionOneDragon == null)
            InitTable_MissionOneDragon();
		Tab_MissionOneDragon result;
		g_MissionOneDragon.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionOneDragon> GetMissionOneDragon()
    {
        if(g_MissionOneDragon == null)
            InitTable_MissionOneDragon();
        return g_MissionOneDragon;
    }
	
    public static bool InitTable_MissionOneDragon()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionOneDragon.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionOneDragon.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionOneDragon.Validate(lines[1]))
			{
				g_MissionOneDragon = new Dictionary<int, Tab_MissionOneDragon>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionOneDragon(line);
						g_MissionOneDragon[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionQuestion> g_MissionQuestion;
	
    public static Tab_MissionQuestion GetMissionQuestionByID(int nKey, int nIndex = 0)
    {
        if(g_MissionQuestion == null)
            InitTable_MissionQuestion();
		Tab_MissionQuestion result;
		g_MissionQuestion.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionQuestion> GetMissionQuestion()
    {
        if(g_MissionQuestion == null)
            InitTable_MissionQuestion();
        return g_MissionQuestion;
    }
	
    public static bool InitTable_MissionQuestion()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionQuestion.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionQuestion.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionQuestion.Validate(lines[1]))
			{
				g_MissionQuestion = new Dictionary<int, Tab_MissionQuestion>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionQuestion(line);
						g_MissionQuestion[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionSortBase> g_MissionSortBase;
	
    public static Tab_MissionSortBase GetMissionSortBaseByID(int nKey, int nIndex = 0)
    {
        if(g_MissionSortBase == null)
            InitTable_MissionSortBase();
		Tab_MissionSortBase result;
		g_MissionSortBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionSortBase> GetMissionSortBase()
    {
        if(g_MissionSortBase == null)
            InitTable_MissionSortBase();
        return g_MissionSortBase;
    }
	
    public static bool InitTable_MissionSortBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionSortBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionSortBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionSortBase.Validate(lines[1]))
			{
				g_MissionSortBase = new Dictionary<int, Tab_MissionSortBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionSortBase(line);
						g_MissionSortBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MissionSortItem> g_MissionSortItem;
	
    public static Tab_MissionSortItem GetMissionSortItemByID(int nKey, int nIndex = 0)
    {
        if(g_MissionSortItem == null)
            InitTable_MissionSortItem();
		Tab_MissionSortItem result;
		g_MissionSortItem.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MissionSortItem> GetMissionSortItem()
    {
        if(g_MissionSortItem == null)
            InitTable_MissionSortItem();
        return g_MissionSortItem;
    }
	
    public static bool InitTable_MissionSortItem()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MissionSortItem.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MissionSortItem.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MissionSortItem.Validate(lines[1]))
			{
				g_MissionSortItem = new Dictionary<int, Tab_MissionSortItem>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MissionSortItem(line);
						g_MissionSortItem[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MoneyTreeReward> g_MoneyTreeReward;
	
    public static Tab_MoneyTreeReward GetMoneyTreeRewardByID(int nKey, int nIndex = 0)
    {
        if(g_MoneyTreeReward == null)
            InitTable_MoneyTreeReward();
		Tab_MoneyTreeReward result;
		g_MoneyTreeReward.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MoneyTreeReward> GetMoneyTreeReward()
    {
        if(g_MoneyTreeReward == null)
            InitTable_MoneyTreeReward();
        return g_MoneyTreeReward;
    }
	
    public static bool InitTable_MoneyTreeReward()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MoneyTreeReward.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MoneyTreeReward.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MoneyTreeReward.Validate(lines[1]))
			{
				g_MoneyTreeReward = new Dictionary<int, Tab_MoneyTreeReward>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MoneyTreeReward(line);
						g_MoneyTreeReward[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_MountBase> g_MountBase;
	
    public static Tab_MountBase GetMountBaseByID(int nKey, int nIndex = 0)
    {
        if(g_MountBase == null)
            InitTable_MountBase();
		Tab_MountBase result;
		g_MountBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_MountBase> GetMountBase()
    {
        if(g_MountBase == null)
            InitTable_MountBase();
        return g_MountBase;
    }
	
    public static bool InitTable_MountBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_MountBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_MountBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_MountBase.Validate(lines[1]))
			{
				g_MountBase = new Dictionary<int, Tab_MountBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_MountBase(line);
						g_MountBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_NewBuyCopyNum> g_NewBuyCopyNum;
	
    public static Tab_NewBuyCopyNum GetNewBuyCopyNumByID(int nKey, int nIndex = 0)
    {
        if(g_NewBuyCopyNum == null)
            InitTable_NewBuyCopyNum();
		Tab_NewBuyCopyNum result;
		g_NewBuyCopyNum.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_NewBuyCopyNum> GetNewBuyCopyNum()
    {
        if(g_NewBuyCopyNum == null)
            InitTable_NewBuyCopyNum();
        return g_NewBuyCopyNum;
    }
	
    public static bool InitTable_NewBuyCopyNum()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_NewBuyCopyNum.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_NewBuyCopyNum.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_NewBuyCopyNum.Validate(lines[1]))
			{
				g_NewBuyCopyNum = new Dictionary<int, Tab_NewBuyCopyNum>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_NewBuyCopyNum(line);
						g_NewBuyCopyNum[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_NewCopyBase> g_NewCopyBase;
	
    public static Tab_NewCopyBase GetNewCopyBaseByID(int nKey, int nIndex = 0)
    {
        if(g_NewCopyBase == null)
            InitTable_NewCopyBase();
		Tab_NewCopyBase result;
		g_NewCopyBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_NewCopyBase> GetNewCopyBase()
    {
        if(g_NewCopyBase == null)
            InitTable_NewCopyBase();
        return g_NewCopyBase;
    }
	
    public static bool InitTable_NewCopyBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_NewCopyBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_NewCopyBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_NewCopyBase.Validate(lines[1]))
			{
				g_NewCopyBase = new Dictionary<int, Tab_NewCopyBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_NewCopyBase(line);
						g_NewCopyBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_NpcDialog> g_NpcDialog;
	
    public static Tab_NpcDialog GetNpcDialogByID(int nKey, int nIndex = 0)
    {
        if(g_NpcDialog == null)
            InitTable_NpcDialog();
		Tab_NpcDialog result;
		g_NpcDialog.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_NpcDialog> GetNpcDialog()
    {
        if(g_NpcDialog == null)
            InitTable_NpcDialog();
        return g_NpcDialog;
    }
	
    public static bool InitTable_NpcDialog()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_NpcDialog.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_NpcDialog.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_NpcDialog.Validate(lines[1]))
			{
				g_NpcDialog = new Dictionary<int, Tab_NpcDialog>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_NpcDialog(line);
						g_NpcDialog[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_NpcOptionDialog> g_NpcOptionDialog;
	
    public static Tab_NpcOptionDialog GetNpcOptionDialogByID(int nKey, int nIndex = 0)
    {
        if(g_NpcOptionDialog == null)
            InitTable_NpcOptionDialog();
		Tab_NpcOptionDialog result;
		g_NpcOptionDialog.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_NpcOptionDialog> GetNpcOptionDialog()
    {
        if(g_NpcOptionDialog == null)
            InitTable_NpcOptionDialog();
        return g_NpcOptionDialog;
    }
	
    public static bool InitTable_NpcOptionDialog()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_NpcOptionDialog.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_NpcOptionDialog.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_NpcOptionDialog.Validate(lines[1]))
			{
				g_NpcOptionDialog = new Dictionary<int, Tab_NpcOptionDialog>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_NpcOptionDialog(line);
						g_NpcOptionDialog[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_OffLineExp> g_OffLineExp;
	
    public static Tab_OffLineExp GetOffLineExpByID(int nKey, int nIndex = 0)
    {
        if(g_OffLineExp == null)
            InitTable_OffLineExp();
		Tab_OffLineExp result;
		g_OffLineExp.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_OffLineExp> GetOffLineExp()
    {
        if(g_OffLineExp == null)
            InitTable_OffLineExp();
        return g_OffLineExp;
    }
	
    public static bool InitTable_OffLineExp()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_OffLineExp.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_OffLineExp.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_OffLineExp.Validate(lines[1]))
			{
				g_OffLineExp = new Dictionary<int, Tab_OffLineExp>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_OffLineExp(line);
						g_OffLineExp[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Ornament> g_Ornament;
	
    public static Tab_Ornament GetOrnamentByID(int nKey, int nIndex = 0)
    {
        if(g_Ornament == null)
            InitTable_Ornament();
		Tab_Ornament result;
		g_Ornament.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Ornament> GetOrnament()
    {
        if(g_Ornament == null)
            InitTable_Ornament();
        return g_Ornament;
    }
	
    public static bool InitTable_Ornament()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Ornament.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Ornament.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Ornament.Validate(lines[1]))
			{
				g_Ornament = new Dictionary<int, Tab_Ornament>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Ornament(line);
						g_Ornament[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_PKDetailInfo> g_PKDetailInfo;
	
    public static Tab_PKDetailInfo GetPKDetailInfoByID(int nKey, int nIndex = 0)
    {
        if(g_PKDetailInfo == null)
            InitTable_PKDetailInfo();
		Tab_PKDetailInfo result;
		g_PKDetailInfo.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_PKDetailInfo> GetPKDetailInfo()
    {
        if(g_PKDetailInfo == null)
            InitTable_PKDetailInfo();
        return g_PKDetailInfo;
    }
	
    public static bool InitTable_PKDetailInfo()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_PKDetailInfo.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_PKDetailInfo.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_PKDetailInfo.Validate(lines[1]))
			{
				g_PKDetailInfo = new Dictionary<int, Tab_PKDetailInfo>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_PKDetailInfo(line);
						g_PKDetailInfo[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_PlayerShopItemPrice> g_PlayerShopItemPrice;
	
    public static Tab_PlayerShopItemPrice GetPlayerShopItemPriceByID(int nKey, int nIndex = 0)
    {
        if(g_PlayerShopItemPrice == null)
            InitTable_PlayerShopItemPrice();
		Tab_PlayerShopItemPrice result;
		g_PlayerShopItemPrice.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_PlayerShopItemPrice> GetPlayerShopItemPrice()
    {
        if(g_PlayerShopItemPrice == null)
            InitTable_PlayerShopItemPrice();
        return g_PlayerShopItemPrice;
    }
	
    public static bool InitTable_PlayerShopItemPrice()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_PlayerShopItemPrice.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_PlayerShopItemPrice.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_PlayerShopItemPrice.Validate(lines[1]))
			{
				g_PlayerShopItemPrice = new Dictionary<int, Tab_PlayerShopItemPrice>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_PlayerShopItemPrice(line);
						g_PlayerShopItemPrice[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_PlayHelpMessage> g_PlayHelpMessage;
	
    public static Tab_PlayHelpMessage GetPlayHelpMessageByID(int nKey, int nIndex = 0)
    {
        if(g_PlayHelpMessage == null)
            InitTable_PlayHelpMessage();
		Tab_PlayHelpMessage result;
		g_PlayHelpMessage.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_PlayHelpMessage> GetPlayHelpMessage()
    {
        if(g_PlayHelpMessage == null)
            InitTable_PlayHelpMessage();
        return g_PlayHelpMessage;
    }
	
    public static bool InitTable_PlayHelpMessage()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_PlayHelpMessage.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_PlayHelpMessage.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_PlayHelpMessage.Validate(lines[1]))
			{
				g_PlayHelpMessage = new Dictionary<int, Tab_PlayHelpMessage>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_PlayHelpMessage(line);
						g_PlayHelpMessage[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_PrivateBoss> g_PrivateBoss;
	
    public static Tab_PrivateBoss GetPrivateBossByID(int nKey, int nIndex = 0)
    {
        if(g_PrivateBoss == null)
            InitTable_PrivateBoss();
		Tab_PrivateBoss result;
		g_PrivateBoss.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_PrivateBoss> GetPrivateBoss()
    {
        if(g_PrivateBoss == null)
            InitTable_PrivateBoss();
        return g_PrivateBoss;
    }
	
    public static bool InitTable_PrivateBoss()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_PrivateBoss.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_PrivateBoss.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_PrivateBoss.Validate(lines[1]))
			{
				g_PrivateBoss = new Dictionary<int, Tab_PrivateBoss>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_PrivateBoss(line);
						g_PrivateBoss[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_PrivilegeFunction> g_PrivilegeFunction;
	
    public static Tab_PrivilegeFunction GetPrivilegeFunctionByID(int nKey, int nIndex = 0)
    {
        if(g_PrivilegeFunction == null)
            InitTable_PrivilegeFunction();
		Tab_PrivilegeFunction result;
		g_PrivilegeFunction.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_PrivilegeFunction> GetPrivilegeFunction()
    {
        if(g_PrivilegeFunction == null)
            InitTable_PrivilegeFunction();
        return g_PrivilegeFunction;
    }
	
    public static bool InitTable_PrivilegeFunction()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_PrivilegeFunction.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_PrivilegeFunction.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_PrivilegeFunction.Validate(lines[1]))
			{
				g_PrivilegeFunction = new Dictionary<int, Tab_PrivilegeFunction>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_PrivilegeFunction(line);
						g_PrivilegeFunction[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_PrivilegeTypeDesc> g_PrivilegeTypeDesc;
	
    public static Tab_PrivilegeTypeDesc GetPrivilegeTypeDescByID(int nKey, int nIndex = 0)
    {
        if(g_PrivilegeTypeDesc == null)
            InitTable_PrivilegeTypeDesc();
		Tab_PrivilegeTypeDesc result;
		g_PrivilegeTypeDesc.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_PrivilegeTypeDesc> GetPrivilegeTypeDesc()
    {
        if(g_PrivilegeTypeDesc == null)
            InitTable_PrivilegeTypeDesc();
        return g_PrivilegeTypeDesc;
    }
	
    public static bool InitTable_PrivilegeTypeDesc()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_PrivilegeTypeDesc.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_PrivilegeTypeDesc.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_PrivilegeTypeDesc.Validate(lines[1]))
			{
				g_PrivilegeTypeDesc = new Dictionary<int, Tab_PrivilegeTypeDesc>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_PrivilegeTypeDesc(line);
						g_PrivilegeTypeDesc[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_PrivilegeVip> g_PrivilegeVip;
	
    public static Tab_PrivilegeVip GetPrivilegeVipByID(int nKey, int nIndex = 0)
    {
        if(g_PrivilegeVip == null)
            InitTable_PrivilegeVip();
		Tab_PrivilegeVip result;
		g_PrivilegeVip.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_PrivilegeVip> GetPrivilegeVip()
    {
        if(g_PrivilegeVip == null)
            InitTable_PrivilegeVip();
        return g_PrivilegeVip;
    }
	
    public static bool InitTable_PrivilegeVip()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_PrivilegeVip.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_PrivilegeVip.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_PrivilegeVip.Validate(lines[1]))
			{
				g_PrivilegeVip = new Dictionary<int, Tab_PrivilegeVip>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_PrivilegeVip(line);
						g_PrivilegeVip[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_PromoteCultivation> g_PromoteCultivation;
	
    public static Tab_PromoteCultivation GetPromoteCultivationByID(int nKey, int nIndex = 0)
    {
        if(g_PromoteCultivation == null)
            InitTable_PromoteCultivation();
		Tab_PromoteCultivation result;
		g_PromoteCultivation.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_PromoteCultivation> GetPromoteCultivation()
    {
        if(g_PromoteCultivation == null)
            InitTable_PromoteCultivation();
        return g_PromoteCultivation;
    }
	
    public static bool InitTable_PromoteCultivation()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_PromoteCultivation.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_PromoteCultivation.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_PromoteCultivation.Validate(lines[1]))
			{
				g_PromoteCultivation = new Dictionary<int, Tab_PromoteCultivation>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_PromoteCultivation(line);
						g_PromoteCultivation[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_PromoteSavvy> g_PromoteSavvy;
	
    public static Tab_PromoteSavvy GetPromoteSavvyByID(int nKey, int nIndex = 0)
    {
        if(g_PromoteSavvy == null)
            InitTable_PromoteSavvy();
		Tab_PromoteSavvy result;
		g_PromoteSavvy.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_PromoteSavvy> GetPromoteSavvy()
    {
        if(g_PromoteSavvy == null)
            InitTable_PromoteSavvy();
        return g_PromoteSavvy;
    }
	
    public static bool InitTable_PromoteSavvy()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_PromoteSavvy.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_PromoteSavvy.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_PromoteSavvy.Validate(lines[1]))
			{
				g_PromoteSavvy = new Dictionary<int, Tab_PromoteSavvy>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_PromoteSavvy(line);
						g_PromoteSavvy[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_PublicConfig> g_PublicConfig;
	
    public static Tab_PublicConfig GetPublicConfigByID(int nKey, int nIndex = 0)
    {
        if(g_PublicConfig == null)
            InitTable_PublicConfig();
		Tab_PublicConfig result;
		g_PublicConfig.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_PublicConfig> GetPublicConfig()
    {
        if(g_PublicConfig == null)
            InitTable_PublicConfig();
        return g_PublicConfig;
    }
	
    public static bool InitTable_PublicConfig()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_PublicConfig.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_PublicConfig.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_PublicConfig.Validate(lines[1]))
			{
				g_PublicConfig = new Dictionary<int, Tab_PublicConfig>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_PublicConfig(line);
						g_PublicConfig[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_PushNotification> g_PushNotification;
	
    public static Tab_PushNotification GetPushNotificationByID(int nKey, int nIndex = 0)
    {
        if(g_PushNotification == null)
            InitTable_PushNotification();
		Tab_PushNotification result;
		g_PushNotification.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_PushNotification> GetPushNotification()
    {
        if(g_PushNotification == null)
            InitTable_PushNotification();
        return g_PushNotification;
    }
	
    public static bool InitTable_PushNotification()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_PushNotification.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_PushNotification.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_PushNotification.Validate(lines[1]))
			{
				g_PushNotification = new Dictionary<int, Tab_PushNotification>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_PushNotification(line);
						g_PushNotification[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_PVPRule> g_PVPRule;
	
    public static Tab_PVPRule GetPVPRuleByID(int nKey, int nIndex = 0)
    {
        if(g_PVPRule == null)
            InitTable_PVPRule();
		Tab_PVPRule result;
		g_PVPRule.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_PVPRule> GetPVPRule()
    {
        if(g_PVPRule == null)
            InitTable_PVPRule();
        return g_PVPRule;
    }
	
    public static bool InitTable_PVPRule()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_PVPRule.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_PVPRule.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_PVPRule.Validate(lines[1]))
			{
				g_PVPRule = new Dictionary<int, Tab_PVPRule>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_PVPRule(line);
						g_PVPRule[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_QuestionBank> g_QuestionBank;
	
    public static Tab_QuestionBank GetQuestionBankByID(int nKey, int nIndex = 0)
    {
        if(g_QuestionBank == null)
            InitTable_QuestionBank();
		Tab_QuestionBank result;
		g_QuestionBank.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_QuestionBank> GetQuestionBank()
    {
        if(g_QuestionBank == null)
            InitTable_QuestionBank();
        return g_QuestionBank;
    }
	
    public static bool InitTable_QuestionBank()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_QuestionBank.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_QuestionBank.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_QuestionBank.Validate(lines[1]))
			{
				g_QuestionBank = new Dictionary<int, Tab_QuestionBank>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_QuestionBank(line);
						g_QuestionBank[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_QuestionOther> g_QuestionOther;
	
    public static Tab_QuestionOther GetQuestionOtherByID(int nKey, int nIndex = 0)
    {
        if(g_QuestionOther == null)
            InitTable_QuestionOther();
		Tab_QuestionOther result;
		g_QuestionOther.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_QuestionOther> GetQuestionOther()
    {
        if(g_QuestionOther == null)
            InitTable_QuestionOther();
        return g_QuestionOther;
    }
	
    public static bool InitTable_QuestionOther()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_QuestionOther.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_QuestionOther.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_QuestionOther.Validate(lines[1]))
			{
				g_QuestionOther = new Dictionary<int, Tab_QuestionOther>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_QuestionOther(line);
						g_QuestionOther[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_RankInfo> g_RankInfo;
	
    public static Tab_RankInfo GetRankInfoByID(int nKey, int nIndex = 0)
    {
        if(g_RankInfo == null)
            InitTable_RankInfo();
		Tab_RankInfo result;
		g_RankInfo.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_RankInfo> GetRankInfo()
    {
        if(g_RankInfo == null)
            InitTable_RankInfo();
        return g_RankInfo;
    }
	
    public static bool InitTable_RankInfo()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_RankInfo.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_RankInfo.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_RankInfo.Validate(lines[1]))
			{
				g_RankInfo = new Dictionary<int, Tab_RankInfo>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_RankInfo(line);
						g_RankInfo[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_RankInfoType> g_RankInfoType;
	
    public static Tab_RankInfoType GetRankInfoTypeByID(int nKey, int nIndex = 0)
    {
        if(g_RankInfoType == null)
            InitTable_RankInfoType();
		Tab_RankInfoType result;
		g_RankInfoType.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_RankInfoType> GetRankInfoType()
    {
        if(g_RankInfoType == null)
            InitTable_RankInfoType();
        return g_RankInfoType;
    }
	
    public static bool InitTable_RankInfoType()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_RankInfoType.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_RankInfoType.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_RankInfoType.Validate(lines[1]))
			{
				g_RankInfoType = new Dictionary<int, Tab_RankInfoType>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_RankInfoType(line);
						g_RankInfoType[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_RankProInfo> g_RankProInfo;
	
    public static Tab_RankProInfo GetRankProInfoByID(int nKey, int nIndex = 0)
    {
        if(g_RankProInfo == null)
            InitTable_RankProInfo();
		Tab_RankProInfo result;
		g_RankProInfo.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_RankProInfo> GetRankProInfo()
    {
        if(g_RankProInfo == null)
            InitTable_RankProInfo();
        return g_RankProInfo;
    }
	
    public static bool InitTable_RankProInfo()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_RankProInfo.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_RankProInfo.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_RankProInfo.Validate(lines[1]))
			{
				g_RankProInfo = new Dictionary<int, Tab_RankProInfo>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_RankProInfo(line);
						g_RankProInfo[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_RankProStr>> g_RankProStr;
	
	public static List<Tab_RankProStr> GetRankProStrByID(int nKey)
    {
        if(g_RankProStr == null)
            InitTable_RankProStr();
		List<Tab_RankProStr> result;
		g_RankProStr.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_RankProStr GetRankProStrByID(int nKey, int nIndex)
    {
        if(g_RankProStr == null)
            InitTable_RankProStr();
		List<Tab_RankProStr> list;
		Tab_RankProStr result = null;
		if (nIndex >= 0 &&
			g_RankProStr.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_RankProStr>> GetRankProStr()
    {
        if(g_RankProStr == null)
            InitTable_RankProStr();
        return g_RankProStr;
    }
	
	public static bool InitTable_RankProStr()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_RankProStr.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_RankProStr.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_RankProStr.Validate(lines[1]))
			{
				g_RankProStr = new Dictionary<int, List<Tab_RankProStr>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_RankProStr(line);
						List<Tab_RankProStr> list;
						var id = item.GetId();
						if (!g_RankProStr.TryGetValue(id, out list))
						{
							list = new List<Tab_RankProStr>();
							g_RankProStr.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Recharge> g_Recharge;
	
    public static Tab_Recharge GetRechargeByID(int nKey, int nIndex = 0)
    {
        if(g_Recharge == null)
            InitTable_Recharge();
		Tab_Recharge result;
		g_Recharge.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Recharge> GetRecharge()
    {
        if(g_Recharge == null)
            InitTable_Recharge();
        return g_Recharge;
    }
	
    public static bool InitTable_Recharge()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Recharge.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Recharge.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Recharge.Validate(lines[1]))
			{
				g_Recharge = new Dictionary<int, Tab_Recharge>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Recharge(line);
						g_Recharge[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_RedPacketRank> g_RedPacketRank;
	
    public static Tab_RedPacketRank GetRedPacketRankByID(int nKey, int nIndex = 0)
    {
        if(g_RedPacketRank == null)
            InitTable_RedPacketRank();
		Tab_RedPacketRank result;
		g_RedPacketRank.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_RedPacketRank> GetRedPacketRank()
    {
        if(g_RedPacketRank == null)
            InitTable_RedPacketRank();
        return g_RedPacketRank;
    }
	
    public static bool InitTable_RedPacketRank()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_RedPacketRank.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_RedPacketRank.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_RedPacketRank.Validate(lines[1]))
			{
				g_RedPacketRank = new Dictionary<int, Tab_RedPacketRank>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_RedPacketRank(line);
						g_RedPacketRank[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Relation> g_Relation;
	
    public static Tab_Relation GetRelationByID(int nKey, int nIndex = 0)
    {
        if(g_Relation == null)
            InitTable_Relation();
		Tab_Relation result;
		g_Relation.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Relation> GetRelation()
    {
        if(g_Relation == null)
            InitTable_Relation();
        return g_Relation;
    }
	
    public static bool InitTable_Relation()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Relation.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Relation.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Relation.Validate(lines[1]))
			{
				g_Relation = new Dictionary<int, Tab_Relation>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Relation(line);
						g_Relation[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Relive> g_Relive;
	
    public static Tab_Relive GetReliveByID(int nKey, int nIndex = 0)
    {
        if(g_Relive == null)
            InitTable_Relive();
		Tab_Relive result;
		g_Relive.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Relive> GetRelive()
    {
        if(g_Relive == null)
            InitTable_Relive();
        return g_Relive;
    }
	
    public static bool InitTable_Relive()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Relive.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Relive.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Relive.Validate(lines[1]))
			{
				g_Relive = new Dictionary<int, Tab_Relive>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Relive(line);
						g_Relive[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_RoleBaseAttr> g_RoleBaseAttr;
	
    public static Tab_RoleBaseAttr GetRoleBaseAttrByID(int nKey, int nIndex = 0)
    {
        if(g_RoleBaseAttr == null)
            InitTable_RoleBaseAttr();
		Tab_RoleBaseAttr result;
		g_RoleBaseAttr.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_RoleBaseAttr> GetRoleBaseAttr()
    {
        if(g_RoleBaseAttr == null)
            InitTable_RoleBaseAttr();
        return g_RoleBaseAttr;
    }
	
    public static bool InitTable_RoleBaseAttr()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_RoleBaseAttr.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_RoleBaseAttr.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_RoleBaseAttr.Validate(lines[1]))
			{
				g_RoleBaseAttr = new Dictionary<int, Tab_RoleBaseAttr>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_RoleBaseAttr(line);
						g_RoleBaseAttr[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_RoleIntegral> g_RoleIntegral;
	
    public static Tab_RoleIntegral GetRoleIntegralByID(int nKey, int nIndex = 0)
    {
        if(g_RoleIntegral == null)
            InitTable_RoleIntegral();
		Tab_RoleIntegral result;
		g_RoleIntegral.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_RoleIntegral> GetRoleIntegral()
    {
        if(g_RoleIntegral == null)
            InitTable_RoleIntegral();
        return g_RoleIntegral;
    }
	
    public static bool InitTable_RoleIntegral()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_RoleIntegral.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_RoleIntegral.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_RoleIntegral.Validate(lines[1]))
			{
				g_RoleIntegral = new Dictionary<int, Tab_RoleIntegral>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_RoleIntegral(line);
						g_RoleIntegral[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_RoleIntegralShop> g_RoleIntegralShop;
	
    public static Tab_RoleIntegralShop GetRoleIntegralShopByID(int nKey, int nIndex = 0)
    {
        if(g_RoleIntegralShop == null)
            InitTable_RoleIntegralShop();
		Tab_RoleIntegralShop result;
		g_RoleIntegralShop.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_RoleIntegralShop> GetRoleIntegralShop()
    {
        if(g_RoleIntegralShop == null)
            InitTable_RoleIntegralShop();
        return g_RoleIntegralShop;
    }
	
    public static bool InitTable_RoleIntegralShop()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_RoleIntegralShop.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_RoleIntegralShop.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_RoleIntegralShop.Validate(lines[1]))
			{
				g_RoleIntegralShop = new Dictionary<int, Tab_RoleIntegralShop>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_RoleIntegralShop(line);
						g_RoleIntegralShop[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_RoleName>> g_RoleName;
	
	public static List<Tab_RoleName> GetRoleNameByID(int nKey)
    {
        if(g_RoleName == null)
            InitTable_RoleName();
		List<Tab_RoleName> result;
		g_RoleName.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_RoleName GetRoleNameByID(int nKey, int nIndex)
    {
        if(g_RoleName == null)
            InitTable_RoleName();
		List<Tab_RoleName> list;
		Tab_RoleName result = null;
		if (nIndex >= 0 &&
			g_RoleName.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_RoleName>> GetRoleName()
    {
        if(g_RoleName == null)
            InitTable_RoleName();
        return g_RoleName;
    }
	
	public static bool InitTable_RoleName()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_RoleName.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_RoleName.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_RoleName.Validate(lines[1]))
			{
				g_RoleName = new Dictionary<int, List<Tab_RoleName>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_RoleName(line);
						List<Tab_RoleName> list;
						var id = item.GetId();
						if (!g_RoleName.TryGetValue(id, out list))
						{
							list = new List<Tab_RoleName>();
							g_RoleName.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_SceneCameraStartPos>> g_SceneCameraStartPos;
	
	public static List<Tab_SceneCameraStartPos> GetSceneCameraStartPosByID(int nKey)
    {
        if(g_SceneCameraStartPos == null)
            InitTable_SceneCameraStartPos();
		List<Tab_SceneCameraStartPos> result;
		g_SceneCameraStartPos.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_SceneCameraStartPos GetSceneCameraStartPosByID(int nKey, int nIndex)
    {
        if(g_SceneCameraStartPos == null)
            InitTable_SceneCameraStartPos();
		List<Tab_SceneCameraStartPos> list;
		Tab_SceneCameraStartPos result = null;
		if (nIndex >= 0 &&
			g_SceneCameraStartPos.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_SceneCameraStartPos>> GetSceneCameraStartPos()
    {
        if(g_SceneCameraStartPos == null)
            InitTable_SceneCameraStartPos();
        return g_SceneCameraStartPos;
    }
	
	public static bool InitTable_SceneCameraStartPos()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SceneCameraStartPos.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SceneCameraStartPos.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SceneCameraStartPos.Validate(lines[1]))
			{
				g_SceneCameraStartPos = new Dictionary<int, List<Tab_SceneCameraStartPos>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SceneCameraStartPos(line);
						List<Tab_SceneCameraStartPos> list;
						var id = item.GetId();
						if (!g_SceneCameraStartPos.TryGetValue(id, out list))
						{
							list = new List<Tab_SceneCameraStartPos>();
							g_SceneCameraStartPos.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SceneClass> g_SceneClass;
	
    public static Tab_SceneClass GetSceneClassByID(int nKey, int nIndex = 0)
    {
        if(g_SceneClass == null)
            InitTable_SceneClass();
		Tab_SceneClass result;
		g_SceneClass.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SceneClass> GetSceneClass()
    {
        if(g_SceneClass == null)
            InitTable_SceneClass();
        return g_SceneClass;
    }
	
    public static bool InitTable_SceneClass()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SceneClass.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SceneClass.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SceneClass.Validate(lines[1]))
			{
				g_SceneClass = new Dictionary<int, Tab_SceneClass>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SceneClass(line);
						g_SceneClass[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SceneItemUse> g_SceneItemUse;
	
    public static Tab_SceneItemUse GetSceneItemUseByID(int nKey, int nIndex = 0)
    {
        if(g_SceneItemUse == null)
            InitTable_SceneItemUse();
		Tab_SceneItemUse result;
		g_SceneItemUse.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SceneItemUse> GetSceneItemUse()
    {
        if(g_SceneItemUse == null)
            InitTable_SceneItemUse();
        return g_SceneItemUse;
    }
	
    public static bool InitTable_SceneItemUse()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SceneItemUse.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SceneItemUse.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SceneItemUse.Validate(lines[1]))
			{
				g_SceneItemUse = new Dictionary<int, Tab_SceneItemUse>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SceneItemUse(line);
						g_SceneItemUse[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SceneMovie> g_SceneMovie;
	
    public static Tab_SceneMovie GetSceneMovieByID(int nKey, int nIndex = 0)
    {
        if(g_SceneMovie == null)
            InitTable_SceneMovie();
		Tab_SceneMovie result;
		g_SceneMovie.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SceneMovie> GetSceneMovie()
    {
        if(g_SceneMovie == null)
            InitTable_SceneMovie();
        return g_SceneMovie;
    }
	
    public static bool InitTable_SceneMovie()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SceneMovie.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SceneMovie.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SceneMovie.Validate(lines[1]))
			{
				g_SceneMovie = new Dictionary<int, Tab_SceneMovie>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SceneMovie(line);
						g_SceneMovie[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SceneNpc> g_SceneNpc;
	
    public static Tab_SceneNpc GetSceneNpcByID(int nKey, int nIndex = 0)
    {
        if(g_SceneNpc == null)
            InitTable_SceneNpc();
		Tab_SceneNpc result;
		g_SceneNpc.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SceneNpc> GetSceneNpc()
    {
        if(g_SceneNpc == null)
            InitTable_SceneNpc();
        return g_SceneNpc;
    }
	
    public static bool InitTable_SceneNpc()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SceneNpc.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SceneNpc.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SceneNpc.Validate(lines[1]))
			{
				g_SceneNpc = new Dictionary<int, Tab_SceneNpc>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SceneNpc(line);
						g_SceneNpc[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ServerLvlCap> g_ServerLvlCap;
	
    public static Tab_ServerLvlCap GetServerLvlCapByID(int nKey, int nIndex = 0)
    {
        if(g_ServerLvlCap == null)
            InitTable_ServerLvlCap();
		Tab_ServerLvlCap result;
		g_ServerLvlCap.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ServerLvlCap> GetServerLvlCap()
    {
        if(g_ServerLvlCap == null)
            InitTable_ServerLvlCap();
        return g_ServerLvlCap;
    }
	
    public static bool InitTable_ServerLvlCap()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ServerLvlCap.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ServerLvlCap.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ServerLvlCap.Validate(lines[1]))
			{
				g_ServerLvlCap = new Dictionary<int, Tab_ServerLvlCap>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ServerLvlCap(line);
						g_ServerLvlCap[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ShopItemLimit> g_ShopItemLimit;
	
    public static Tab_ShopItemLimit GetShopItemLimitByID(int nKey, int nIndex = 0)
    {
        if(g_ShopItemLimit == null)
            InitTable_ShopItemLimit();
		Tab_ShopItemLimit result;
		g_ShopItemLimit.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ShopItemLimit> GetShopItemLimit()
    {
        if(g_ShopItemLimit == null)
            InitTable_ShopItemLimit();
        return g_ShopItemLimit;
    }
	
    public static bool InitTable_ShopItemLimit()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ShopItemLimit.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ShopItemLimit.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ShopItemLimit.Validate(lines[1]))
			{
				g_ShopItemLimit = new Dictionary<int, Tab_ShopItemLimit>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ShopItemLimit(line);
						g_ShopItemLimit[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SignPost> g_SignPost;
	
    public static Tab_SignPost GetSignPostByID(int nKey, int nIndex = 0)
    {
        if(g_SignPost == null)
            InitTable_SignPost();
		Tab_SignPost result;
		g_SignPost.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SignPost> GetSignPost()
    {
        if(g_SignPost == null)
            InitTable_SignPost();
        return g_SignPost;
    }
	
    public static bool InitTable_SignPost()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SignPost.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SignPost.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SignPost.Validate(lines[1]))
			{
				g_SignPost = new Dictionary<int, Tab_SignPost>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SignPost(line);
						g_SignPost[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SkillActive> g_SkillActive;
	
    public static Tab_SkillActive GetSkillActiveByID(int nKey, int nIndex = 0)
    {
        if(g_SkillActive == null)
            InitTable_SkillActive();
		Tab_SkillActive result;
		g_SkillActive.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SkillActive> GetSkillActive()
    {
        if(g_SkillActive == null)
            InitTable_SkillActive();
        return g_SkillActive;
    }
	
    public static bool InitTable_SkillActive()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SkillActive.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SkillActive.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SkillActive.Validate(lines[1]))
			{
				g_SkillActive = new Dictionary<int, Tab_SkillActive>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SkillActive(line);
						g_SkillActive[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SkillBase> g_SkillBase;
	
    public static Tab_SkillBase GetSkillBaseByID(int nKey, int nIndex = 0)
    {
        if(g_SkillBase == null)
            InitTable_SkillBase();
		Tab_SkillBase result;
		g_SkillBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SkillBase> GetSkillBase()
    {
        if(g_SkillBase == null)
            InitTable_SkillBase();
        return g_SkillBase;
    }
	
    public static bool InitTable_SkillBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SkillBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SkillBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SkillBase.Validate(lines[1]))
			{
				g_SkillBase = new Dictionary<int, Tab_SkillBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SkillBase(line);
						g_SkillBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SkillBoxOpen> g_SkillBoxOpen;
	
    public static Tab_SkillBoxOpen GetSkillBoxOpenByID(int nKey, int nIndex = 0)
    {
        if(g_SkillBoxOpen == null)
            InitTable_SkillBoxOpen();
		Tab_SkillBoxOpen result;
		g_SkillBoxOpen.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SkillBoxOpen> GetSkillBoxOpen()
    {
        if(g_SkillBoxOpen == null)
            InitTable_SkillBoxOpen();
        return g_SkillBoxOpen;
    }
	
    public static bool InitTable_SkillBoxOpen()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SkillBoxOpen.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SkillBoxOpen.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SkillBoxOpen.Validate(lines[1]))
			{
				g_SkillBoxOpen = new Dictionary<int, Tab_SkillBoxOpen>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SkillBoxOpen(line);
						g_SkillBoxOpen[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SkillEx> g_SkillEx;
	
    public static Tab_SkillEx GetSkillExByID(int nKey, int nIndex = 0)
    {
        if(g_SkillEx == null)
            InitTable_SkillEx();
		Tab_SkillEx result;
		g_SkillEx.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SkillEx> GetSkillEx()
    {
        if(g_SkillEx == null)
            InitTable_SkillEx();
        return g_SkillEx;
    }
	
    public static bool InitTable_SkillEx()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SkillEx.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SkillEx.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SkillEx.Validate(lines[1]))
			{
				g_SkillEx = new Dictionary<int, Tab_SkillEx>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SkillEx(line);
						g_SkillEx[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SkillEx1> g_SkillEx1;
	
    public static Tab_SkillEx1 GetSkillEx1ByID(int nKey, int nIndex = 0)
    {
        if(g_SkillEx1 == null)
            InitTable_SkillEx1();
		Tab_SkillEx1 result;
		g_SkillEx1.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SkillEx1> GetSkillEx1()
    {
        if(g_SkillEx1 == null)
            InitTable_SkillEx1();
        return g_SkillEx1;
    }
	
    public static bool InitTable_SkillEx1()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SkillEx1.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SkillEx1.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SkillEx1.Validate(lines[1]))
			{
				g_SkillEx1 = new Dictionary<int, Tab_SkillEx1>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SkillEx1(line);
						g_SkillEx1[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SkillLearn> g_SkillLearn;
	
    public static Tab_SkillLearn GetSkillLearnByID(int nKey, int nIndex = 0)
    {
        if(g_SkillLearn == null)
            InitTable_SkillLearn();
		Tab_SkillLearn result;
		g_SkillLearn.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SkillLearn> GetSkillLearn()
    {
        if(g_SkillLearn == null)
            InitTable_SkillLearn();
        return g_SkillLearn;
    }
	
    public static bool InitTable_SkillLearn()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SkillLearn.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SkillLearn.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SkillLearn.Validate(lines[1]))
			{
				g_SkillLearn = new Dictionary<int, Tab_SkillLearn>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SkillLearn(line);
						g_SkillLearn[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SkillLevelUp> g_SkillLevelUp;
	
    public static Tab_SkillLevelUp GetSkillLevelUpByID(int nKey, int nIndex = 0)
    {
        if(g_SkillLevelUp == null)
            InitTable_SkillLevelUp();
		Tab_SkillLevelUp result;
		g_SkillLevelUp.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SkillLevelUp> GetSkillLevelUp()
    {
        if(g_SkillLevelUp == null)
            InitTable_SkillLevelUp();
        return g_SkillLevelUp;
    }
	
    public static bool InitTable_SkillLevelUp()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SkillLevelUp.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SkillLevelUp.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SkillLevelUp.Validate(lines[1]))
			{
				g_SkillLevelUp = new Dictionary<int, Tab_SkillLevelUp>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SkillLevelUp(line);
						g_SkillLevelUp[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SkillTargetSelector> g_SkillTargetSelector;
	
    public static Tab_SkillTargetSelector GetSkillTargetSelectorByID(int nKey, int nIndex = 0)
    {
        if(g_SkillTargetSelector == null)
            InitTable_SkillTargetSelector();
		Tab_SkillTargetSelector result;
		g_SkillTargetSelector.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SkillTargetSelector> GetSkillTargetSelector()
    {
        if(g_SkillTargetSelector == null)
            InitTable_SkillTargetSelector();
        return g_SkillTargetSelector;
    }
	
    public static bool InitTable_SkillTargetSelector()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SkillTargetSelector.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SkillTargetSelector.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SkillTargetSelector.Validate(lines[1]))
			{
				g_SkillTargetSelector = new Dictionary<int, Tab_SkillTargetSelector>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SkillTargetSelector(line);
						g_SkillTargetSelector[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SnareObjInfo> g_SnareObjInfo;
	
    public static Tab_SnareObjInfo GetSnareObjInfoByID(int nKey, int nIndex = 0)
    {
        if(g_SnareObjInfo == null)
            InitTable_SnareObjInfo();
		Tab_SnareObjInfo result;
		g_SnareObjInfo.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SnareObjInfo> GetSnareObjInfo()
    {
        if(g_SnareObjInfo == null)
            InitTable_SnareObjInfo();
        return g_SnareObjInfo;
    }
	
    public static bool InitTable_SnareObjInfo()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SnareObjInfo.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SnareObjInfo.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SnareObjInfo.Validate(lines[1]))
			{
				g_SnareObjInfo = new Dictionary<int, Tab_SnareObjInfo>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SnareObjInfo(line);
						g_SnareObjInfo[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SnatchTreasure> g_SnatchTreasure;
	
    public static Tab_SnatchTreasure GetSnatchTreasureByID(int nKey, int nIndex = 0)
    {
        if(g_SnatchTreasure == null)
            InitTable_SnatchTreasure();
		Tab_SnatchTreasure result;
		g_SnatchTreasure.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SnatchTreasure> GetSnatchTreasure()
    {
        if(g_SnatchTreasure == null)
            InitTable_SnatchTreasure();
        return g_SnatchTreasure;
    }
	
    public static bool InitTable_SnatchTreasure()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SnatchTreasure.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SnatchTreasure.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SnatchTreasure.Validate(lines[1]))
			{
				g_SnatchTreasure = new Dictionary<int, Tab_SnatchTreasure>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SnatchTreasure(line);
						g_SnatchTreasure[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SoulBase> g_SoulBase;
	
    public static Tab_SoulBase GetSoulBaseByID(int nKey, int nIndex = 0)
    {
        if(g_SoulBase == null)
            InitTable_SoulBase();
		Tab_SoulBase result;
		g_SoulBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SoulBase> GetSoulBase()
    {
        if(g_SoulBase == null)
            InitTable_SoulBase();
        return g_SoulBase;
    }
	
    public static bool InitTable_SoulBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SoulBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SoulBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SoulBase.Validate(lines[1]))
			{
				g_SoulBase = new Dictionary<int, Tab_SoulBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SoulBase(line);
						g_SoulBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SoulGeneralAttr> g_SoulGeneralAttr;
	
    public static Tab_SoulGeneralAttr GetSoulGeneralAttrByID(int nKey, int nIndex = 0)
    {
        if(g_SoulGeneralAttr == null)
            InitTable_SoulGeneralAttr();
		Tab_SoulGeneralAttr result;
		g_SoulGeneralAttr.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SoulGeneralAttr> GetSoulGeneralAttr()
    {
        if(g_SoulGeneralAttr == null)
            InitTable_SoulGeneralAttr();
        return g_SoulGeneralAttr;
    }
	
    public static bool InitTable_SoulGeneralAttr()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SoulGeneralAttr.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SoulGeneralAttr.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SoulGeneralAttr.Validate(lines[1]))
			{
				g_SoulGeneralAttr = new Dictionary<int, Tab_SoulGeneralAttr>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SoulGeneralAttr(line);
						g_SoulGeneralAttr[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SoulGeneralLink> g_SoulGeneralLink;
	
    public static Tab_SoulGeneralLink GetSoulGeneralLinkByID(int nKey, int nIndex = 0)
    {
        if(g_SoulGeneralLink == null)
            InitTable_SoulGeneralLink();
		Tab_SoulGeneralLink result;
		g_SoulGeneralLink.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SoulGeneralLink> GetSoulGeneralLink()
    {
        if(g_SoulGeneralLink == null)
            InitTable_SoulGeneralLink();
        return g_SoulGeneralLink;
    }
	
    public static bool InitTable_SoulGeneralLink()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SoulGeneralLink.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SoulGeneralLink.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SoulGeneralLink.Validate(lines[1]))
			{
				g_SoulGeneralLink = new Dictionary<int, Tab_SoulGeneralLink>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SoulGeneralLink(line);
						g_SoulGeneralLink[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SoulGeneralStar> g_SoulGeneralStar;
	
    public static Tab_SoulGeneralStar GetSoulGeneralStarByID(int nKey, int nIndex = 0)
    {
        if(g_SoulGeneralStar == null)
            InitTable_SoulGeneralStar();
		Tab_SoulGeneralStar result;
		g_SoulGeneralStar.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SoulGeneralStar> GetSoulGeneralStar()
    {
        if(g_SoulGeneralStar == null)
            InitTable_SoulGeneralStar();
        return g_SoulGeneralStar;
    }
	
    public static bool InitTable_SoulGeneralStar()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SoulGeneralStar.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SoulGeneralStar.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SoulGeneralStar.Validate(lines[1]))
			{
				g_SoulGeneralStar = new Dictionary<int, Tab_SoulGeneralStar>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SoulGeneralStar(line);
						g_SoulGeneralStar[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SoulHeavenAttr> g_SoulHeavenAttr;
	
    public static Tab_SoulHeavenAttr GetSoulHeavenAttrByID(int nKey, int nIndex = 0)
    {
        if(g_SoulHeavenAttr == null)
            InitTable_SoulHeavenAttr();
		Tab_SoulHeavenAttr result;
		g_SoulHeavenAttr.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SoulHeavenAttr> GetSoulHeavenAttr()
    {
        if(g_SoulHeavenAttr == null)
            InitTable_SoulHeavenAttr();
        return g_SoulHeavenAttr;
    }
	
    public static bool InitTable_SoulHeavenAttr()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SoulHeavenAttr.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SoulHeavenAttr.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SoulHeavenAttr.Validate(lines[1]))
			{
				g_SoulHeavenAttr = new Dictionary<int, Tab_SoulHeavenAttr>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SoulHeavenAttr(line);
						g_SoulHeavenAttr[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SoulHeavenUnlock> g_SoulHeavenUnlock;
	
    public static Tab_SoulHeavenUnlock GetSoulHeavenUnlockByID(int nKey, int nIndex = 0)
    {
        if(g_SoulHeavenUnlock == null)
            InitTable_SoulHeavenUnlock();
		Tab_SoulHeavenUnlock result;
		g_SoulHeavenUnlock.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SoulHeavenUnlock> GetSoulHeavenUnlock()
    {
        if(g_SoulHeavenUnlock == null)
            InitTable_SoulHeavenUnlock();
        return g_SoulHeavenUnlock;
    }
	
    public static bool InitTable_SoulHeavenUnlock()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SoulHeavenUnlock.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SoulHeavenUnlock.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SoulHeavenUnlock.Validate(lines[1]))
			{
				g_SoulHeavenUnlock = new Dictionary<int, Tab_SoulHeavenUnlock>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SoulHeavenUnlock(line);
						g_SoulHeavenUnlock[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Sounds> g_Sounds;
	
    public static Tab_Sounds GetSoundsByID(int nKey, int nIndex = 0)
    {
        if(g_Sounds == null)
            InitTable_Sounds();
		Tab_Sounds result;
		g_Sounds.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Sounds> GetSounds()
    {
        if(g_Sounds == null)
            InitTable_Sounds();
        return g_Sounds;
    }
	
    public static bool InitTable_Sounds()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Sounds.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Sounds.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Sounds.Validate(lines[1]))
			{
				g_Sounds = new Dictionary<int, Tab_Sounds>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Sounds(line);
						g_Sounds[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Stamp> g_Stamp;
	
    public static Tab_Stamp GetStampByID(int nKey, int nIndex = 0)
    {
        if(g_Stamp == null)
            InitTable_Stamp();
		Tab_Stamp result;
		g_Stamp.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Stamp> GetStamp()
    {
        if(g_Stamp == null)
            InitTable_Stamp();
        return g_Stamp;
    }
	
    public static bool InitTable_Stamp()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Stamp.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Stamp.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Stamp.Validate(lines[1]))
			{
				g_Stamp = new Dictionary<int, Tab_Stamp>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Stamp(line);
						g_Stamp[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_StaticFunc> g_StaticFunc;
	
    public static Tab_StaticFunc GetStaticFuncByID(int nKey, int nIndex = 0)
    {
        if(g_StaticFunc == null)
            InitTable_StaticFunc();
		Tab_StaticFunc result;
		g_StaticFunc.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_StaticFunc> GetStaticFunc()
    {
        if(g_StaticFunc == null)
            InitTable_StaticFunc();
        return g_StaticFunc;
    }
	
    public static bool InitTable_StaticFunc()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_StaticFunc.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_StaticFunc.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_StaticFunc.Validate(lines[1]))
			{
				g_StaticFunc = new Dictionary<int, Tab_StaticFunc>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_StaticFunc(line);
						g_StaticFunc[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, List<Tab_StrDictionary>> g_StrDictionary;
	
	public static List<Tab_StrDictionary> GetStrDictionaryByID(int nKey)
    {
        if(g_StrDictionary == null)
            InitTable_StrDictionary();
		List<Tab_StrDictionary> result;
		g_StrDictionary.TryGetValue(nKey, out result);
		return result;
	}

	public static Tab_StrDictionary GetStrDictionaryByID(int nKey, int nIndex)
    {
        if(g_StrDictionary == null)
            InitTable_StrDictionary();
		List<Tab_StrDictionary> list;
		Tab_StrDictionary result = null;
		if (nIndex >= 0 &&
			g_StrDictionary.TryGetValue(nKey, out list) &&
			nIndex < list.Count)
				result = list[nIndex];
		return result;
	}
	
	public static Dictionary<int, List<Tab_StrDictionary>> GetStrDictionary()
    {
        if(g_StrDictionary == null)
            InitTable_StrDictionary();
        return g_StrDictionary;
    }
	
	public static bool InitTable_StrDictionary()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_StrDictionary.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_StrDictionary.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_StrDictionary.Validate(lines[1]))
			{
				g_StrDictionary = new Dictionary<int, List<Tab_StrDictionary>>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_StrDictionary(line);
						List<Tab_StrDictionary> list;
						var id = item.GetId();
						if (!g_StrDictionary.TryGetValue(id, out list))
						{
							list = new List<Tab_StrDictionary>();
							g_StrDictionary.Add(id, list);
						}
						list.Add(item);
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_StrFilter> g_StrFilter;
	
    public static Tab_StrFilter GetStrFilterByID(int nKey, int nIndex = 0)
    {
        if(g_StrFilter == null)
            InitTable_StrFilter();
		Tab_StrFilter result;
		g_StrFilter.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_StrFilter> GetStrFilter()
    {
        if(g_StrFilter == null)
            InitTable_StrFilter();
        return g_StrFilter;
    }
	
    public static bool InitTable_StrFilter()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_StrFilter.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_StrFilter.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_StrFilter.Validate(lines[1]))
			{
				g_StrFilter = new Dictionary<int, Tab_StrFilter>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_StrFilter(line);
						g_StrFilter[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_StroyCopy> g_StroyCopy;
	
    public static Tab_StroyCopy GetStroyCopyByID(int nKey, int nIndex = 0)
    {
        if(g_StroyCopy == null)
            InitTable_StroyCopy();
		Tab_StroyCopy result;
		g_StroyCopy.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_StroyCopy> GetStroyCopy()
    {
        if(g_StroyCopy == null)
            InitTable_StroyCopy();
        return g_StroyCopy;
    }
	
    public static bool InitTable_StroyCopy()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_StroyCopy.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_StroyCopy.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_StroyCopy.Validate(lines[1]))
			{
				g_StroyCopy = new Dictionary<int, Tab_StroyCopy>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_StroyCopy(line);
						g_StroyCopy[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SwornBase> g_SwornBase;
	
    public static Tab_SwornBase GetSwornBaseByID(int nKey, int nIndex = 0)
    {
        if(g_SwornBase == null)
            InitTable_SwornBase();
		Tab_SwornBase result;
		g_SwornBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SwornBase> GetSwornBase()
    {
        if(g_SwornBase == null)
            InitTable_SwornBase();
        return g_SwornBase;
    }
	
    public static bool InitTable_SwornBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SwornBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SwornBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SwornBase.Validate(lines[1]))
			{
				g_SwornBase = new Dictionary<int, Tab_SwornBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SwornBase(line);
						g_SwornBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SystemParam> g_SystemParam;
	
    public static Tab_SystemParam GetSystemParamByID(int nKey, int nIndex = 0)
    {
        if(g_SystemParam == null)
            InitTable_SystemParam();
		Tab_SystemParam result;
		g_SystemParam.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SystemParam> GetSystemParam()
    {
        if(g_SystemParam == null)
            InitTable_SystemParam();
        return g_SystemParam;
    }
	
    public static bool InitTable_SystemParam()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SystemParam.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SystemParam.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SystemParam.Validate(lines[1]))
			{
				g_SystemParam = new Dictionary<int, Tab_SystemParam>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SystemParam(line);
						g_SystemParam[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_SystemShop> g_SystemShop;
	
    public static Tab_SystemShop GetSystemShopByID(int nKey, int nIndex = 0)
    {
        if(g_SystemShop == null)
            InitTable_SystemShop();
		Tab_SystemShop result;
		g_SystemShop.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_SystemShop> GetSystemShop()
    {
        if(g_SystemShop == null)
            InitTable_SystemShop();
        return g_SystemShop;
    }
	
    public static bool InitTable_SystemShop()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_SystemShop.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_SystemShop.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_SystemShop.Validate(lines[1]))
			{
				g_SystemShop = new Dictionary<int, Tab_SystemShop>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_SystemShop(line);
						g_SystemShop[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_TeamLeaderAwardActivity> g_TeamLeaderAwardActivity;
	
    public static Tab_TeamLeaderAwardActivity GetTeamLeaderAwardActivityByID(int nKey, int nIndex = 0)
    {
        if(g_TeamLeaderAwardActivity == null)
            InitTable_TeamLeaderAwardActivity();
		Tab_TeamLeaderAwardActivity result;
		g_TeamLeaderAwardActivity.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_TeamLeaderAwardActivity> GetTeamLeaderAwardActivity()
    {
        if(g_TeamLeaderAwardActivity == null)
            InitTable_TeamLeaderAwardActivity();
        return g_TeamLeaderAwardActivity;
    }
	
    public static bool InitTable_TeamLeaderAwardActivity()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_TeamLeaderAwardActivity.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_TeamLeaderAwardActivity.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_TeamLeaderAwardActivity.Validate(lines[1]))
			{
				g_TeamLeaderAwardActivity = new Dictionary<int, Tab_TeamLeaderAwardActivity>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_TeamLeaderAwardActivity(line);
						g_TeamLeaderAwardActivity[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_TeamLeaderAwardItem> g_TeamLeaderAwardItem;
	
    public static Tab_TeamLeaderAwardItem GetTeamLeaderAwardItemByID(int nKey, int nIndex = 0)
    {
        if(g_TeamLeaderAwardItem == null)
            InitTable_TeamLeaderAwardItem();
		Tab_TeamLeaderAwardItem result;
		g_TeamLeaderAwardItem.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_TeamLeaderAwardItem> GetTeamLeaderAwardItem()
    {
        if(g_TeamLeaderAwardItem == null)
            InitTable_TeamLeaderAwardItem();
        return g_TeamLeaderAwardItem;
    }
	
    public static bool InitTable_TeamLeaderAwardItem()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_TeamLeaderAwardItem.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_TeamLeaderAwardItem.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_TeamLeaderAwardItem.Validate(lines[1]))
			{
				g_TeamLeaderAwardItem = new Dictionary<int, Tab_TeamLeaderAwardItem>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_TeamLeaderAwardItem(line);
						g_TeamLeaderAwardItem[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_TeamLeaderAwardLevel> g_TeamLeaderAwardLevel;
	
    public static Tab_TeamLeaderAwardLevel GetTeamLeaderAwardLevelByID(int nKey, int nIndex = 0)
    {
        if(g_TeamLeaderAwardLevel == null)
            InitTable_TeamLeaderAwardLevel();
		Tab_TeamLeaderAwardLevel result;
		g_TeamLeaderAwardLevel.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_TeamLeaderAwardLevel> GetTeamLeaderAwardLevel()
    {
        if(g_TeamLeaderAwardLevel == null)
            InitTable_TeamLeaderAwardLevel();
        return g_TeamLeaderAwardLevel;
    }
	
    public static bool InitTable_TeamLeaderAwardLevel()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_TeamLeaderAwardLevel.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_TeamLeaderAwardLevel.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_TeamLeaderAwardLevel.Validate(lines[1]))
			{
				g_TeamLeaderAwardLevel = new Dictionary<int, Tab_TeamLeaderAwardLevel>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_TeamLeaderAwardLevel(line);
						g_TeamLeaderAwardLevel[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_TeamLeaderAwardWeek> g_TeamLeaderAwardWeek;
	
    public static Tab_TeamLeaderAwardWeek GetTeamLeaderAwardWeekByID(int nKey, int nIndex = 0)
    {
        if(g_TeamLeaderAwardWeek == null)
            InitTable_TeamLeaderAwardWeek();
		Tab_TeamLeaderAwardWeek result;
		g_TeamLeaderAwardWeek.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_TeamLeaderAwardWeek> GetTeamLeaderAwardWeek()
    {
        if(g_TeamLeaderAwardWeek == null)
            InitTable_TeamLeaderAwardWeek();
        return g_TeamLeaderAwardWeek;
    }
	
    public static bool InitTable_TeamLeaderAwardWeek()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_TeamLeaderAwardWeek.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_TeamLeaderAwardWeek.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_TeamLeaderAwardWeek.Validate(lines[1]))
			{
				g_TeamLeaderAwardWeek = new Dictionary<int, Tab_TeamLeaderAwardWeek>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_TeamLeaderAwardWeek(line);
						g_TeamLeaderAwardWeek[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_TeamTarget> g_TeamTarget;
	
    public static Tab_TeamTarget GetTeamTargetByID(int nKey, int nIndex = 0)
    {
        if(g_TeamTarget == null)
            InitTable_TeamTarget();
		Tab_TeamTarget result;
		g_TeamTarget.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_TeamTarget> GetTeamTarget()
    {
        if(g_TeamTarget == null)
            InitTable_TeamTarget();
        return g_TeamTarget;
    }
	
    public static bool InitTable_TeamTarget()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_TeamTarget.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_TeamTarget.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_TeamTarget.Validate(lines[1]))
			{
				g_TeamTarget = new Dictionary<int, Tab_TeamTarget>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_TeamTarget(line);
						g_TeamTarget[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Teleport> g_Teleport;
	
    public static Tab_Teleport GetTeleportByID(int nKey, int nIndex = 0)
    {
        if(g_Teleport == null)
            InitTable_Teleport();
		Tab_Teleport result;
		g_Teleport.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Teleport> GetTeleport()
    {
        if(g_Teleport == null)
            InitTable_Teleport();
        return g_Teleport;
    }
	
    public static bool InitTable_Teleport()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Teleport.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Teleport.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Teleport.Validate(lines[1]))
			{
				g_Teleport = new Dictionary<int, Tab_Teleport>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Teleport(line);
						g_Teleport[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_TestingCopy> g_TestingCopy;
	
    public static Tab_TestingCopy GetTestingCopyByID(int nKey, int nIndex = 0)
    {
        if(g_TestingCopy == null)
            InitTable_TestingCopy();
		Tab_TestingCopy result;
		g_TestingCopy.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_TestingCopy> GetTestingCopy()
    {
        if(g_TestingCopy == null)
            InitTable_TestingCopy();
        return g_TestingCopy;
    }
	
    public static bool InitTable_TestingCopy()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_TestingCopy.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_TestingCopy.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_TestingCopy.Validate(lines[1]))
			{
				g_TestingCopy = new Dictionary<int, Tab_TestingCopy>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_TestingCopy(line);
						g_TestingCopy[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_TestingCopyOnceAward> g_TestingCopyOnceAward;
	
    public static Tab_TestingCopyOnceAward GetTestingCopyOnceAwardByID(int nKey, int nIndex = 0)
    {
        if(g_TestingCopyOnceAward == null)
            InitTable_TestingCopyOnceAward();
		Tab_TestingCopyOnceAward result;
		g_TestingCopyOnceAward.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_TestingCopyOnceAward> GetTestingCopyOnceAward()
    {
        if(g_TestingCopyOnceAward == null)
            InitTable_TestingCopyOnceAward();
        return g_TestingCopyOnceAward;
    }
	
    public static bool InitTable_TestingCopyOnceAward()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_TestingCopyOnceAward.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_TestingCopyOnceAward.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_TestingCopyOnceAward.Validate(lines[1]))
			{
				g_TestingCopyOnceAward = new Dictionary<int, Tab_TestingCopyOnceAward>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_TestingCopyOnceAward(line);
						g_TestingCopyOnceAward[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_TestingDfCopy> g_TestingDfCopy;
	
    public static Tab_TestingDfCopy GetTestingDfCopyByID(int nKey, int nIndex = 0)
    {
        if(g_TestingDfCopy == null)
            InitTable_TestingDfCopy();
		Tab_TestingDfCopy result;
		g_TestingDfCopy.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_TestingDfCopy> GetTestingDfCopy()
    {
        if(g_TestingDfCopy == null)
            InitTable_TestingDfCopy();
        return g_TestingDfCopy;
    }
	
    public static bool InitTable_TestingDfCopy()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_TestingDfCopy.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_TestingDfCopy.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_TestingDfCopy.Validate(lines[1]))
			{
				g_TestingDfCopy = new Dictionary<int, Tab_TestingDfCopy>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_TestingDfCopy(line);
						g_TestingDfCopy[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_TitleData> g_TitleData;
	
    public static Tab_TitleData GetTitleDataByID(int nKey, int nIndex = 0)
    {
        if(g_TitleData == null)
            InitTable_TitleData();
		Tab_TitleData result;
		g_TitleData.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_TitleData> GetTitleData()
    {
        if(g_TitleData == null)
            InitTable_TitleData();
        return g_TitleData;
    }
	
    public static bool InitTable_TitleData()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_TitleData.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_TitleData.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_TitleData.Validate(lines[1]))
			{
				g_TitleData = new Dictionary<int, Tab_TitleData>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_TitleData(line);
						g_TitleData[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_TitleType> g_TitleType;
	
    public static Tab_TitleType GetTitleTypeByID(int nKey, int nIndex = 0)
    {
        if(g_TitleType == null)
            InitTable_TitleType();
		Tab_TitleType result;
		g_TitleType.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_TitleType> GetTitleType()
    {
        if(g_TitleType == null)
            InitTable_TitleType();
        return g_TitleType;
    }
	
    public static bool InitTable_TitleType()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_TitleType.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_TitleType.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_TitleType.Validate(lines[1]))
			{
				g_TitleType = new Dictionary<int, Tab_TitleType>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_TitleType(line);
						g_TitleType[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_TreasureBase> g_TreasureBase;
	
    public static Tab_TreasureBase GetTreasureBaseByID(int nKey, int nIndex = 0)
    {
        if(g_TreasureBase == null)
            InitTable_TreasureBase();
		Tab_TreasureBase result;
		g_TreasureBase.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_TreasureBase> GetTreasureBase()
    {
        if(g_TreasureBase == null)
            InitTable_TreasureBase();
        return g_TreasureBase;
    }
	
    public static bool InitTable_TreasureBase()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_TreasureBase.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_TreasureBase.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_TreasureBase.Validate(lines[1]))
			{
				g_TreasureBase = new Dictionary<int, Tab_TreasureBase>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_TreasureBase(line);
						g_TreasureBase[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_UsableItem> g_UsableItem;
	
    public static Tab_UsableItem GetUsableItemByID(int nKey, int nIndex = 0)
    {
        if(g_UsableItem == null)
            InitTable_UsableItem();
		Tab_UsableItem result;
		g_UsableItem.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_UsableItem> GetUsableItem()
    {
        if(g_UsableItem == null)
            InitTable_UsableItem();
        return g_UsableItem;
    }
	
    public static bool InitTable_UsableItem()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_UsableItem.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_UsableItem.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_UsableItem.Validate(lines[1]))
			{
				g_UsableItem = new Dictionary<int, Tab_UsableItem>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_UsableItem(line);
						g_UsableItem[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_UseDrugItem> g_UseDrugItem;
	
    public static Tab_UseDrugItem GetUseDrugItemByID(int nKey, int nIndex = 0)
    {
        if(g_UseDrugItem == null)
            InitTable_UseDrugItem();
		Tab_UseDrugItem result;
		g_UseDrugItem.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_UseDrugItem> GetUseDrugItem()
    {
        if(g_UseDrugItem == null)
            InitTable_UseDrugItem();
        return g_UseDrugItem;
    }
	
    public static bool InitTable_UseDrugItem()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_UseDrugItem.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_UseDrugItem.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_UseDrugItem.Validate(lines[1]))
			{
				g_UseDrugItem = new Dictionary<int, Tab_UseDrugItem>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_UseDrugItem(line);
						g_UseDrugItem[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_UserChallengeBuyNum> g_UserChallengeBuyNum;
	
    public static Tab_UserChallengeBuyNum GetUserChallengeBuyNumByID(int nKey, int nIndex = 0)
    {
        if(g_UserChallengeBuyNum == null)
            InitTable_UserChallengeBuyNum();
		Tab_UserChallengeBuyNum result;
		g_UserChallengeBuyNum.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_UserChallengeBuyNum> GetUserChallengeBuyNum()
    {
        if(g_UserChallengeBuyNum == null)
            InitTable_UserChallengeBuyNum();
        return g_UserChallengeBuyNum;
    }
	
    public static bool InitTable_UserChallengeBuyNum()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_UserChallengeBuyNum.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_UserChallengeBuyNum.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_UserChallengeBuyNum.Validate(lines[1]))
			{
				g_UserChallengeBuyNum = new Dictionary<int, Tab_UserChallengeBuyNum>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_UserChallengeBuyNum(line);
						g_UserChallengeBuyNum[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_UserShopItem> g_UserShopItem;
	
    public static Tab_UserShopItem GetUserShopItemByID(int nKey, int nIndex = 0)
    {
        if(g_UserShopItem == null)
            InitTable_UserShopItem();
		Tab_UserShopItem result;
		g_UserShopItem.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_UserShopItem> GetUserShopItem()
    {
        if(g_UserShopItem == null)
            InitTable_UserShopItem();
        return g_UserShopItem;
    }
	
    public static bool InitTable_UserShopItem()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_UserShopItem.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_UserShopItem.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_UserShopItem.Validate(lines[1]))
			{
				g_UserShopItem = new Dictionary<int, Tab_UserShopItem>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_UserShopItem(line);
						g_UserShopItem[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_UsershopOpenSlot> g_UsershopOpenSlot;
	
    public static Tab_UsershopOpenSlot GetUsershopOpenSlotByID(int nKey, int nIndex = 0)
    {
        if(g_UsershopOpenSlot == null)
            InitTable_UsershopOpenSlot();
		Tab_UsershopOpenSlot result;
		g_UsershopOpenSlot.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_UsershopOpenSlot> GetUsershopOpenSlot()
    {
        if(g_UsershopOpenSlot == null)
            InitTable_UsershopOpenSlot();
        return g_UsershopOpenSlot;
    }
	
    public static bool InitTable_UsershopOpenSlot()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_UsershopOpenSlot.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_UsershopOpenSlot.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_UsershopOpenSlot.Validate(lines[1]))
			{
				g_UsershopOpenSlot = new Dictionary<int, Tab_UsershopOpenSlot>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_UsershopOpenSlot(line);
						g_UsershopOpenSlot[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_ValhallaGodGeneralStartProp> g_ValhallaGodGeneralStartProp;
	
    public static Tab_ValhallaGodGeneralStartProp GetValhallaGodGeneralStartPropByID(int nKey, int nIndex = 0)
    {
        if(g_ValhallaGodGeneralStartProp == null)
            InitTable_ValhallaGodGeneralStartProp();
		Tab_ValhallaGodGeneralStartProp result;
		g_ValhallaGodGeneralStartProp.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_ValhallaGodGeneralStartProp> GetValhallaGodGeneralStartProp()
    {
        if(g_ValhallaGodGeneralStartProp == null)
            InitTable_ValhallaGodGeneralStartProp();
        return g_ValhallaGodGeneralStartProp;
    }
	
    public static bool InitTable_ValhallaGodGeneralStartProp()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_ValhallaGodGeneralStartProp.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_ValhallaGodGeneralStartProp.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_ValhallaGodGeneralStartProp.Validate(lines[1]))
			{
				g_ValhallaGodGeneralStartProp = new Dictionary<int, Tab_ValhallaGodGeneralStartProp>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_ValhallaGodGeneralStartProp(line);
						g_ValhallaGodGeneralStartProp[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_VipBo1ok> g_VipBo1ok;
	
    public static Tab_VipBo1ok GetVipBo1okByID(int nKey, int nIndex = 0)
    {
        if(g_VipBo1ok == null)
            InitTable_VipBo1ok();
		Tab_VipBo1ok result;
		g_VipBo1ok.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_VipBo1ok> GetVipBo1ok()
    {
        if(g_VipBo1ok == null)
            InitTable_VipBo1ok();
        return g_VipBo1ok;
    }
	
    public static bool InitTable_VipBo1ok()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_VipBo1ok.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_VipBo1ok.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_VipBo1ok.Validate(lines[1]))
			{
				g_VipBo1ok = new Dictionary<int, Tab_VipBo1ok>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_VipBo1ok(line);
						g_VipBo1ok[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_VipBook> g_VipBook;
	
    public static Tab_VipBook GetVipBookByID(int nKey, int nIndex = 0)
    {
        if(g_VipBook == null)
            InitTable_VipBook();
		Tab_VipBook result;
		g_VipBook.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_VipBook> GetVipBook()
    {
        if(g_VipBook == null)
            InitTable_VipBook();
        return g_VipBook;
    }
	
    public static bool InitTable_VipBook()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_VipBook.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_VipBook.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_VipBook.Validate(lines[1]))
			{
				g_VipBook = new Dictionary<int, Tab_VipBook>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_VipBook(line);
						g_VipBook[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_VipIdoitInCharge> g_VipIdoitInCharge;
	
    public static Tab_VipIdoitInCharge GetVipIdoitInChargeByID(int nKey, int nIndex = 0)
    {
        if(g_VipIdoitInCharge == null)
            InitTable_VipIdoitInCharge();
		Tab_VipIdoitInCharge result;
		g_VipIdoitInCharge.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_VipIdoitInCharge> GetVipIdoitInCharge()
    {
        if(g_VipIdoitInCharge == null)
            InitTable_VipIdoitInCharge();
        return g_VipIdoitInCharge;
    }
	
    public static bool InitTable_VipIdoitInCharge()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_VipIdoitInCharge.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_VipIdoitInCharge.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_VipIdoitInCharge.Validate(lines[1]))
			{
				g_VipIdoitInCharge = new Dictionary<int, Tab_VipIdoitInCharge>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_VipIdoitInCharge(line);
						g_VipIdoitInCharge[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_WeaponModel> g_WeaponModel;
	
    public static Tab_WeaponModel GetWeaponModelByID(int nKey, int nIndex = 0)
    {
        if(g_WeaponModel == null)
            InitTable_WeaponModel();
		Tab_WeaponModel result;
		g_WeaponModel.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_WeaponModel> GetWeaponModel()
    {
        if(g_WeaponModel == null)
            InitTable_WeaponModel();
        return g_WeaponModel;
    }
	
    public static bool InitTable_WeaponModel()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_WeaponModel.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_WeaponModel.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_WeaponModel.Validate(lines[1]))
			{
				g_WeaponModel = new Dictionary<int, Tab_WeaponModel>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_WeaponModel(line);
						g_WeaponModel[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_WeddingCandy> g_WeddingCandy;
	
    public static Tab_WeddingCandy GetWeddingCandyByID(int nKey, int nIndex = 0)
    {
        if(g_WeddingCandy == null)
            InitTable_WeddingCandy();
		Tab_WeddingCandy result;
		g_WeddingCandy.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_WeddingCandy> GetWeddingCandy()
    {
        if(g_WeddingCandy == null)
            InitTable_WeddingCandy();
        return g_WeddingCandy;
    }
	
    public static bool InitTable_WeddingCandy()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_WeddingCandy.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_WeddingCandy.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_WeddingCandy.Validate(lines[1]))
			{
				g_WeddingCandy = new Dictionary<int, Tab_WeddingCandy>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_WeddingCandy(line);
						g_WeddingCandy[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_WeddingCarBook> g_WeddingCarBook;
	
    public static Tab_WeddingCarBook GetWeddingCarBookByID(int nKey, int nIndex = 0)
    {
        if(g_WeddingCarBook == null)
            InitTable_WeddingCarBook();
		Tab_WeddingCarBook result;
		g_WeddingCarBook.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_WeddingCarBook> GetWeddingCarBook()
    {
        if(g_WeddingCarBook == null)
            InitTable_WeddingCarBook();
        return g_WeddingCarBook;
    }
	
    public static bool InitTable_WeddingCarBook()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_WeddingCarBook.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_WeddingCarBook.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_WeddingCarBook.Validate(lines[1]))
			{
				g_WeddingCarBook = new Dictionary<int, Tab_WeddingCarBook>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_WeddingCarBook(line);
						g_WeddingCarBook[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_WeddingCarConfig> g_WeddingCarConfig;
	
    public static Tab_WeddingCarConfig GetWeddingCarConfigByID(int nKey, int nIndex = 0)
    {
        if(g_WeddingCarConfig == null)
            InitTable_WeddingCarConfig();
		Tab_WeddingCarConfig result;
		g_WeddingCarConfig.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_WeddingCarConfig> GetWeddingCarConfig()
    {
        if(g_WeddingCarConfig == null)
            InitTable_WeddingCarConfig();
        return g_WeddingCarConfig;
    }
	
    public static bool InitTable_WeddingCarConfig()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_WeddingCarConfig.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_WeddingCarConfig.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_WeddingCarConfig.Validate(lines[1]))
			{
				g_WeddingCarConfig = new Dictionary<int, Tab_WeddingCarConfig>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_WeddingCarConfig(line);
						g_WeddingCarConfig[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_WeddingFireworks> g_WeddingFireworks;
	
    public static Tab_WeddingFireworks GetWeddingFireworksByID(int nKey, int nIndex = 0)
    {
        if(g_WeddingFireworks == null)
            InitTable_WeddingFireworks();
		Tab_WeddingFireworks result;
		g_WeddingFireworks.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_WeddingFireworks> GetWeddingFireworks()
    {
        if(g_WeddingFireworks == null)
            InitTable_WeddingFireworks();
        return g_WeddingFireworks;
    }
	
    public static bool InitTable_WeddingFireworks()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_WeddingFireworks.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_WeddingFireworks.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_WeddingFireworks.Validate(lines[1]))
			{
				g_WeddingFireworks = new Dictionary<int, Tab_WeddingFireworks>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_WeddingFireworks(line);
						g_WeddingFireworks[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_WeedingBanQuet> g_WeedingBanQuet;
	
    public static Tab_WeedingBanQuet GetWeedingBanQuetByID(int nKey, int nIndex = 0)
    {
        if(g_WeedingBanQuet == null)
            InitTable_WeedingBanQuet();
		Tab_WeedingBanQuet result;
		g_WeedingBanQuet.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_WeedingBanQuet> GetWeedingBanQuet()
    {
        if(g_WeedingBanQuet == null)
            InitTable_WeedingBanQuet();
        return g_WeedingBanQuet;
    }
	
    public static bool InitTable_WeedingBanQuet()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_WeedingBanQuet.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_WeedingBanQuet.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_WeedingBanQuet.Validate(lines[1]))
			{
				g_WeedingBanQuet = new Dictionary<int, Tab_WeedingBanQuet>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_WeedingBanQuet(line);
						g_WeedingBanQuet[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_WeedingConfig> g_WeedingConfig;
	
    public static Tab_WeedingConfig GetWeedingConfigByID(int nKey, int nIndex = 0)
    {
        if(g_WeedingConfig == null)
            InitTable_WeedingConfig();
		Tab_WeedingConfig result;
		g_WeedingConfig.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_WeedingConfig> GetWeedingConfig()
    {
        if(g_WeedingConfig == null)
            InitTable_WeedingConfig();
        return g_WeedingConfig;
    }
	
    public static bool InitTable_WeedingConfig()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_WeedingConfig.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_WeedingConfig.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_WeedingConfig.Validate(lines[1]))
			{
				g_WeedingConfig = new Dictionary<int, Tab_WeedingConfig>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_WeedingConfig(line);
						g_WeedingConfig[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_Weibo> g_Weibo;
	
    public static Tab_Weibo GetWeiboByID(int nKey, int nIndex = 0)
    {
        if(g_Weibo == null)
            InitTable_Weibo();
		Tab_Weibo result;
		g_Weibo.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_Weibo> GetWeibo()
    {
        if(g_Weibo == null)
            InitTable_Weibo();
        return g_Weibo;
    }
	
    public static bool InitTable_Weibo()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_Weibo.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_Weibo.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_Weibo.Validate(lines[1]))
			{
				g_Weibo = new Dictionary<int, Tab_Weibo>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_Weibo(line);
						g_Weibo[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_WorldBoss> g_WorldBoss;
	
    public static Tab_WorldBoss GetWorldBossByID(int nKey, int nIndex = 0)
    {
        if(g_WorldBoss == null)
            InitTable_WorldBoss();
		Tab_WorldBoss result;
		g_WorldBoss.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_WorldBoss> GetWorldBoss()
    {
        if(g_WorldBoss == null)
            InitTable_WorldBoss();
        return g_WorldBoss;
    }
	
    public static bool InitTable_WorldBoss()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_WorldBoss.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_WorldBoss.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_WorldBoss.Validate(lines[1]))
			{
				g_WorldBoss = new Dictionary<int, Tab_WorldBoss>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_WorldBoss(line);
						g_WorldBoss[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_WorldBossConfig> g_WorldBossConfig;
	
    public static Tab_WorldBossConfig GetWorldBossConfigByID(int nKey, int nIndex = 0)
    {
        if(g_WorldBossConfig == null)
            InitTable_WorldBossConfig();
		Tab_WorldBossConfig result;
		g_WorldBossConfig.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_WorldBossConfig> GetWorldBossConfig()
    {
        if(g_WorldBossConfig == null)
            InitTable_WorldBossConfig();
        return g_WorldBossConfig;
    }
	
    public static bool InitTable_WorldBossConfig()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_WorldBossConfig.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_WorldBossConfig.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_WorldBossConfig.Validate(lines[1]))
			{
				g_WorldBossConfig = new Dictionary<int, Tab_WorldBossConfig>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_WorldBossConfig(line);
						g_WorldBossConfig[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    private static Dictionary<int, Tab_YuanBaoShop> g_YuanBaoShop;
	
    public static Tab_YuanBaoShop GetYuanBaoShopByID(int nKey, int nIndex = 0)
    {
        if(g_YuanBaoShop == null)
            InitTable_YuanBaoShop();
		Tab_YuanBaoShop result;
		g_YuanBaoShop.TryGetValue(nKey, out result);
		return result;
    }
	
    public static Dictionary<int, Tab_YuanBaoShop> GetYuanBaoShop()
    {
        if(g_YuanBaoShop == null)
            InitTable_YuanBaoShop();
        return g_YuanBaoShop;
    }
	
    public static bool InitTable_YuanBaoShop()
    {
		var result = false;
		var textAsset = LoadAssetBundle.Instance.LoadTableAsset(Tab_YuanBaoShop.TAB_FILE_DATA);
		if (textAsset == null)
            LogModule.ErrorLog("Unable to load textAsset for table " + Tab_YuanBaoShop.TAB_FILE_DATA);
		else
		{
			var lines = textAsset.text.Split('\n');
			if (lines.Length > 2 && Tab_YuanBaoShop.Validate(lines[1]))
			{
				g_YuanBaoShop = new Dictionary<int, Tab_YuanBaoShop>();
				for (var i = 2; i < lines.Length; i++)
				{
					var line = lines[i];
					if (!string.IsNullOrEmpty(line) && !line[0].Equals('#') && !line[0].Equals('\t'))
					{
						var item = new Tab_YuanBaoShop(line);
						g_YuanBaoShop[item.GetId()] = item;
					}
				}
				result = true;
			}
		}
		return result;
    }
  

    }
}