new table system

SCHALE.Common/Crypto/MersenneTwister.cs

@@ -0,0 +1,137 @@
+namespace SCHALE.Common.Crypto
+{
+    public class MersenneTwister
+    {
+        private const int N = 624;
+        private const int M = 397;
+        private const uint MATRIX_A = 0x9908B0DF;
+        private const uint UPPER_MASK = 0x80000000;
+        private const uint LOWER_MASK = 0x7FFFFFFF;
+        private const int MAX_RAND_INT = 0x7FFFFFFF;
+
+        private uint[] mag01 = { 0x0, MATRIX_A };
+        private uint[] mt = new uint[N];
+        private int mti = N + 1;
+
+        public MersenneTwister(int? seed = null)
+        {
+            seed ??= (int)DateTimeOffset.Now.ToUnixTimeSeconds();
+            init_genrand((uint)seed);
+        }
+
+        public int Next(int minValue = 0, int? maxValue = null)
+        {
+            if (maxValue == null)
+            {
+                return genrand_int31();
+            }
+
+            if (minValue > maxValue)
+            {
+                (minValue, maxValue) = (maxValue.Value, minValue);
+            }
+
+            return (int)Math.Floor((maxValue.Value - minValue + 1) * genrand_real1() + minValue);
+        }
+
+        public double NextDouble(bool includeOne = false)
+        {
+            if (includeOne)
+            {
+                return genrand_real1();
+            }
+            return genrand_real2();
+        }
+
+        public double NextDoublePositive()
+        {
+            return genrand_real3();
+        }
+
+        public double Next53BitRes()
+        {
+            return genrand_res53();
+        }
+
+        public byte[] NextBytes(int length)
+        {
+            byte[] bytes = new byte[length];
+            for (int i = 0; i < length; i += 4)
+            {
+                uint randInt = (uint)genrand_int31();
+                byte[] intBytes = BitConverter.GetBytes(randInt);
+                Array.Copy(intBytes, 0, bytes, i, Math.Min(4, length - i));
+            }
+            return bytes;
+        }
+
+        private void init_genrand(uint s)
+        {
+            mt[0] = s;
+            for (int i = 1; i < N; i++)
+            {
+                mt[i] = (uint)(1812433253 * (mt[i - 1] ^ (mt[i - 1] >> 30)) + i);
+            }
+            mti = N;
+        }
+
+        private uint genrand_int32()
+        {
+            uint y;
+            if (mti >= N)
+            {
+                if (mti == N + 1)
+                {
+                    init_genrand(5489);
+                }
+                for (int kk = 0; kk < N - M; kk++)
+                {
+                    y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);
+                    mt[kk] = mt[kk + M] ^ (y >> 1) ^ mag01[y & 0x1];
+                }
+                for (int kk = N - M; kk < N - 1; kk++)
+                {
+                    y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);
+                    mt[kk] = mt[kk + (M - N)] ^ (y >> 1) ^ mag01[y & 0x1];
+                }
+                y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK);
+                mt[N - 1] = mt[M - 1] ^ (y >> 1) ^ mag01[y & 0x1];
+                mti = 0;
+            }
+            y = mt[mti++];
+            y ^= (y >> 11);
+            y ^= (y << 7) & 0x9D2C5680;
+            y ^= (y << 15) & 0xEFC60000;
+            y ^= (y >> 18);
+            return y;
+        }
+
+        private int genrand_int31()
+        {
+            return (int)(genrand_int32() >> 1);
+        }
+
+        private double genrand_real1()
+        {
+            return genrand_int32() * (1.0 / 4294967295.0);
+        }
+
+        private double genrand_real2()
+        {
+            return genrand_int32() * (1.0 / 4294967296.0);
+        }
+
+        private double genrand_real3()
+        {
+            return (genrand_int32() + 0.5) * (1.0 / 4294967296.0);
+        }
+
+        private double genrand_res53()
+        {
+            uint a = genrand_int32() >> 5;
+            uint b = genrand_int32() >> 6;
+            return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0);
+        }
+    }
+
+}

SCHALE.Common/Crypto/TableEncryptionService.cs

@@ -1,12 +1,40 @@
-using MersenneTwister;
+using SCHALE.Common.Crypto.XXHash;
-using SCHALE.Common.Crypto.XXHash;
 using System.Buffers.Binary;
+using System.Collections;
+using System.Reflection;
 using System.Text;
 
 namespace SCHALE.Common.Crypto
 {
     public static class TableEncryptionService
     {
+        private static readonly Dictionary<Type, MethodInfo?> converterCache = [];
+        private static readonly Dictionary<string, byte[]> keyCache = [];
+
+        public static byte[] CreateKey(string name)
+        {
+            if (keyCache.TryGetValue(name, out var key))
+                return key;
+
+            byte[] password = GC.AllocateUninitializedArray<byte>(8);
+
+            using var xxhash = XXHash32.Create();
+            xxhash.ComputeHash(Encoding.UTF8.GetBytes(name));
+
+            var mt = new MersenneTwister((int)xxhash.HashUInt32);
+
+            int i = 0;
+            while (i < password.Length)
+            {
+                Array.Copy(BitConverter.GetBytes(mt.Next()), 0, password, i, Math.Min(4, password.Length - i));
+                i += 4;
+            }
+
+            keyCache.Add(name, password);
+
+            return password;
+        }
+
         /// <summary>
         /// Used for decrypting .bytes flatbuffers bin. Doesn't work yet
         /// </summary>
@@ -17,22 +45,162 @@ namespace SCHALE.Common.Crypto
             using var xxhash = XXHash32.Create();
             xxhash.ComputeHash(Encoding.UTF8.GetBytes(name));
 
-            var mt = MTRandom.Create((int)xxhash.HashUInt32);
+            var mt = new MersenneTwister((int)xxhash.HashUInt32);
-            var key = GC.AllocateUninitializedArray<byte>(sizeof(int));
+            var key = mt.NextBytes(bytes.Length);
-            BinaryPrimitives.WriteInt32LittleEndian(key, mt.Next() + 1);
+            Crypto.XOR.Crypt(bytes, key);
-
-            int i = 0;
-            int j = 0;
-            while (i < bytes.Length)
-            {
-                if (j == 4)
-                {
-                    key = key = GC.AllocateUninitializedArray<byte>(sizeof(int));
-                    BinaryPrimitives.WriteInt32LittleEndian(key, mt.Next() + 1);
-                    j = 0;
         }
 
-                bytes[i++] ^= key[j++];
+        public static MethodInfo? GetConvertMethod(Type type)
+        {
+            if (!converterCache.TryGetValue(type, out MethodInfo? convertMethod))
+            {
+                convertMethod = typeof(TableEncryptionService).GetMethods(BindingFlags.Static | BindingFlags.Public)
+                    .FirstOrDefault(x => x.Name == nameof(Convert) && (x.ReturnType == type));
+                converterCache.Add(type, convertMethod);
+            }
+
+            return convertMethod;
+        }
+
+        public static List<T> Convert<T>(List<T> value, byte[] key) where T : class
+        {
+            var baseType = value.GetType().GenericTypeArguments[0];
+            var convertMethod = GetConvertMethod(baseType.IsEnum ? Enum.GetUnderlyingType(value.GetType()) : baseType);
+            if (convertMethod is null)
+                return value;
+
+            for (int i = 0; i < value.Count; i++)
+            {
+                value[i] = (T)convertMethod.Invoke(null, [value[i], key])!;
+            }
+
+            return value;
+        }
+
+        public static T Convert<T>(T value, byte[] key) where T : Enum
+        {
+            var convertMethod = GetConvertMethod(Enum.GetUnderlyingType(value.GetType()));
+            if (convertMethod is null)
+                return value;
+
+            return (T)convertMethod.Invoke(null, [value, key])!;
+        }
+
+        public static bool Convert(bool value, byte[] key)
+        {
+            return value;
+        }
+
+        public static int Convert(int value, byte[] key)
+        {
+            var bytes = GC.AllocateUninitializedArray<byte>(sizeof(int));
+            BinaryPrimitives.WriteInt32LittleEndian(bytes, value);
+            Crypto.XOR.Crypt(bytes, key);
+
+            return BinaryPrimitives.ReadInt32LittleEndian(bytes);
+        }
+
+        public static long Convert(long value, byte[] key)
+        {
+            var bytes = GC.AllocateUninitializedArray<byte>(sizeof(long));
+            BinaryPrimitives.WriteInt64LittleEndian(bytes, value);
+            Crypto.XOR.Crypt(bytes, key);
+
+            return BinaryPrimitives.ReadInt64LittleEndian(bytes);
+        }
+
+        public static uint Convert(uint value, byte[] key)
+        {
+            var bytes = GC.AllocateUninitializedArray<byte>(sizeof(uint));
+            BinaryPrimitives.WriteUInt32LittleEndian(bytes, value);
+            Crypto.XOR.Crypt(bytes, key);
+
+            return BinaryPrimitives.ReadUInt32LittleEndian(bytes);
+        }
+
+        public static ulong Convert(ulong value, byte[] key)
+        {
+            var bytes = GC.AllocateUninitializedArray<byte>(sizeof(ulong));
+            BinaryPrimitives.WriteUInt64LittleEndian(bytes, value);
+            Crypto.XOR.Crypt(bytes, key);
+
+            return BinaryPrimitives.ReadUInt64LittleEndian(bytes);
+        }
+
+        public static float Convert(float value, byte[] key)
+        {
+            var bytes = GC.AllocateUninitializedArray<byte>(sizeof(float));
+            BinaryPrimitives.WriteSingleLittleEndian(bytes, value);
+            Crypto.XOR.Crypt(bytes, key);
+
+            return BinaryPrimitives.ReadSingleLittleEndian(bytes);
+        }
+
+        public static double Convert(double value, byte[] key)
+        {
+            var bytes = GC.AllocateUninitializedArray<byte>(sizeof(double));
+            BinaryPrimitives.WriteDoubleLittleEndian(bytes, value);
+            Crypto.XOR.Crypt(bytes, key);
+
+            return BinaryPrimitives.ReadDoubleLittleEndian(bytes);
+        }
+
+        public static string Convert(string value, byte[] key)
+        {
+            var strBytes = System.Convert.FromBase64String(value);
+            Crypto.XOR.Crypt(strBytes, key);
+
+            return Encoding.Unicode.GetString(strBytes);
+        }
+    }
+
+    public static class FlatBuffersExtension
+    {
+        private static readonly Dictionary<Type, PropertyInfo[]> propertiesCache = [];
+        private static readonly Dictionary<Type, byte[]> keyCache = [];
+
+        /// <summary>
+        /// <b>Only</b> to be invoked by ExcelT, and only be invoked <b>once</b> per object.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="table"></param>
+        public static void Decode<T>(this T table) where T : class
+        {
+            var type = table.GetType();
+            PropertyInfo[] props;
+
+            if (!propertiesCache.TryGetValue(type, out props!))
+            {
+                props = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
+                propertiesCache.Add(type, props);
+            }
+            
+            foreach (var prop in props)
+            {
+                byte[] key;
+                if (!keyCache.TryGetValue(type, out key!))
+                {
+                    key = TableEncryptionService.CreateKey(type.Name.Replace("ExcelT", ""));
+                    keyCache.Add(type, key);
+                }
+
+                var baseType = prop.PropertyType.Name == "List`1" ? prop.PropertyType.GenericTypeArguments[0] : prop.PropertyType;
+                var convertMethod = TableEncryptionService.GetConvertMethod(baseType.IsEnum ? Enum.GetUnderlyingType(baseType) : baseType);
+                if (convertMethod is not null)
+                {
+                    if (prop.PropertyType.Name == "List`1")
+                    {
+                        var list = (IList)prop.GetValue(table, null)!;
+                        for (int i = 0; i < list.Count; i++)
+                        {
+                            list[i] = convertMethod.Invoke(null, [list[i], key]);
+                        }
+                    }
+                    else
+                    {
+                        prop.SetValue(table, convertMethod.Invoke(null, [prop.GetValue(table, null), key]));
+                    }
+                }
             }
         }
     }

SCHALE.Common/Crypto/TableService.cs

@@ -1,5 +1,9 @@
-using MersenneTwister;
+using Google.FlatBuffers;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
 using SCHALE.Common.Crypto.XXHash;
+using SCHALE.Common.FlatData;
+using System.Reflection;
 using System.Text;
 
 namespace SCHALE.Common.Crypto
@@ -19,17 +23,39 @@ namespace SCHALE.Common.Crypto
             using var xxhash = XXHash32.Create();
             xxhash.ComputeHash(Encoding.UTF8.GetBytes(key));
 
-            var mt = MTRandom.Create((int)xxhash.HashUInt32);
+            var mt = new MersenneTwister((int)xxhash.HashUInt32);
 
             int i = 0;
             while (i < password.Length)
             {
-                // IDK why the random result is off by one in this implementation compared to the game's
+                Array.Copy(BitConverter.GetBytes(mt.Next()), 0, password, i, Math.Min(4, password.Length - i));
-                Array.Copy(BitConverter.GetBytes(mt.Next() + 1), 0, password, i, Math.Min(4, password.Length - i));
                 i += 4;
             }
 
             return password;
         }
+
+#if DEBUG
+        public static void DumpExcels(string bytesDir, string destDir)
+        {
+            foreach (var type in Assembly.GetAssembly(typeof(AcademyFavorScheduleExcelTable))!.GetTypes().Where(t => t.IsAssignableTo(typeof(IFlatbufferObject)) && t.Name.EndsWith("ExcelTable")))
+            {
+                var bytesFilePath = Path.Join(bytesDir, $"{type.Name}.bytes");
+                if (!File.Exists(bytesFilePath))
+                {
+                    Console.WriteLine($"bytes files for {type.Name} not found. skipping...");
+                    continue;
+                }
+
+                var bytes = File.ReadAllBytes(bytesFilePath);
+                TableEncryptionService.XOR(type.Name, bytes);
+                var inst = type.GetMethod($"GetRootAs{type.Name}", BindingFlags.Static | BindingFlags.Public, [typeof(ByteBuffer)])!.Invoke(null, [new ByteBuffer(bytes)]);
+
+                var obj = type.GetMethod("UnPack", BindingFlags.Instance | BindingFlags.Public)!.Invoke(inst, null);
+                File.WriteAllText(Path.Join(destDir, $"{type.Name}.json"), JsonConvert.SerializeObject(obj, Formatting.Indented, new StringEnumConverter()));
+                Console.WriteLine($"Dumped {type.Name} successfully");
+            }
+        }
+#endif
     }
 }

SCHALE.Common/Database/SCHALEContext.cs

@@ -3,7 +3,6 @@ using Microsoft.EntityFrameworkCore.ChangeTracking;
 using Microsoft.EntityFrameworkCore.ValueGeneration;
 using MongoDB.EntityFrameworkCore.Extensions;
 using SCHALE.Common.Database.Models;
-using System.Text.Json;
 
 namespace SCHALE.Common.Database
 {

SCHALE.Common/FlatData/AcademyFavorScheduleExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyFavorScheduleExcel : IFlatbufferObject
@@ -120,6 +121,93 @@ public struct AcademyFavorScheduleExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyFavorScheduleExcel>(o);
   }
+  public AcademyFavorScheduleExcelT UnPack() {
+    var _o = new AcademyFavorScheduleExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyFavorScheduleExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyFavorSchedule");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.CharacterId = TableEncryptionService.Convert(this.CharacterId, key);
+    _o.ScheduleGroupId = TableEncryptionService.Convert(this.ScheduleGroupId, key);
+    _o.OrderInGroup = TableEncryptionService.Convert(this.OrderInGroup, key);
+    _o.Location = TableEncryptionService.Convert(this.Location, key);
+    _o.LocalizeScenarioId = TableEncryptionService.Convert(this.LocalizeScenarioId, key);
+    _o.FavorRank = TableEncryptionService.Convert(this.FavorRank, key);
+    _o.SecretStoneAmount = TableEncryptionService.Convert(this.SecretStoneAmount, key);
+    _o.ScenarioSriptGroupId = TableEncryptionService.Convert(this.ScenarioSriptGroupId, key);
+    _o.RewardParcelType = new List<SCHALE.Common.FlatData.ParcelType>();
+    for (var _j = 0; _j < this.RewardParcelTypeLength; ++_j) {_o.RewardParcelType.Add(TableEncryptionService.Convert(this.RewardParcelType(_j), key));}
+    _o.RewardParcelId = new List<long>();
+    for (var _j = 0; _j < this.RewardParcelIdLength; ++_j) {_o.RewardParcelId.Add(TableEncryptionService.Convert(this.RewardParcelId(_j), key));}
+    _o.RewardAmount = new List<long>();
+    for (var _j = 0; _j < this.RewardAmountLength; ++_j) {_o.RewardAmount.Add(TableEncryptionService.Convert(this.RewardAmount(_j), key));}
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyFavorScheduleExcel> Pack(FlatBufferBuilder builder, AcademyFavorScheduleExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyFavorScheduleExcel>);
+    var _Location = _o.Location == null ? default(StringOffset) : builder.CreateString(_o.Location);
+    var _RewardParcelType = default(VectorOffset);
+    if (_o.RewardParcelType != null) {
+      var __RewardParcelType = _o.RewardParcelType.ToArray();
+      _RewardParcelType = CreateRewardParcelTypeVector(builder, __RewardParcelType);
+    }
+    var _RewardParcelId = default(VectorOffset);
+    if (_o.RewardParcelId != null) {
+      var __RewardParcelId = _o.RewardParcelId.ToArray();
+      _RewardParcelId = CreateRewardParcelIdVector(builder, __RewardParcelId);
+    }
+    var _RewardAmount = default(VectorOffset);
+    if (_o.RewardAmount != null) {
+      var __RewardAmount = _o.RewardAmount.ToArray();
+      _RewardAmount = CreateRewardAmountVector(builder, __RewardAmount);
+    }
+    return CreateAcademyFavorScheduleExcel(
+      builder,
+      _o.Id,
+      _o.CharacterId,
+      _o.ScheduleGroupId,
+      _o.OrderInGroup,
+      _Location,
+      _o.LocalizeScenarioId,
+      _o.FavorRank,
+      _o.SecretStoneAmount,
+      _o.ScenarioSriptGroupId,
+      _RewardParcelType,
+      _RewardParcelId,
+      _RewardAmount);
+  }
+}
+
+public class AcademyFavorScheduleExcelT
+{
+  public long Id { get; set; }
+  public long CharacterId { get; set; }
+  public long ScheduleGroupId { get; set; }
+  public long OrderInGroup { get; set; }
+  public string Location { get; set; }
+  public uint LocalizeScenarioId { get; set; }
+  public long FavorRank { get; set; }
+  public long SecretStoneAmount { get; set; }
+  public long ScenarioSriptGroupId { get; set; }
+  public List<SCHALE.Common.FlatData.ParcelType> RewardParcelType { get; set; }
+  public List<long> RewardParcelId { get; set; }
+  public List<long> RewardAmount { get; set; }
+
+  public AcademyFavorScheduleExcelT() {
+    this.Id = 0;
+    this.CharacterId = 0;
+    this.ScheduleGroupId = 0;
+    this.OrderInGroup = 0;
+    this.Location = null;
+    this.LocalizeScenarioId = 0;
+    this.FavorRank = 0;
+    this.SecretStoneAmount = 0;
+    this.ScenarioSriptGroupId = 0;
+    this.RewardParcelType = null;
+    this.RewardParcelId = null;
+    this.RewardAmount = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyFavorScheduleExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyFavorScheduleExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct AcademyFavorScheduleExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyFavorScheduleExcelTable>(o);
   }
+  public AcademyFavorScheduleExcelTableT UnPack() {
+    var _o = new AcademyFavorScheduleExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyFavorScheduleExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyFavorScheduleExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.AcademyFavorScheduleExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyFavorScheduleExcelTable> Pack(FlatBufferBuilder builder, AcademyFavorScheduleExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyFavorScheduleExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.AcademyFavorScheduleExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.AcademyFavorScheduleExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAcademyFavorScheduleExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class AcademyFavorScheduleExcelTableT
+{
+  public List<SCHALE.Common.FlatData.AcademyFavorScheduleExcelT> DataList { get; set; }
+
+  public AcademyFavorScheduleExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyLocationExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyLocationExcel : IFlatbufferObject
@@ -102,6 +103,76 @@ public struct AcademyLocationExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyLocationExcel>(o);
   }
+  public AcademyLocationExcelT UnPack() {
+    var _o = new AcademyLocationExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyLocationExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyLocation");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.LocalizeEtcId = TableEncryptionService.Convert(this.LocalizeEtcId, key);
+    _o.PrefabPath = TableEncryptionService.Convert(this.PrefabPath, key);
+    _o.IconImagePath = TableEncryptionService.Convert(this.IconImagePath, key);
+    _o.OpenCondition = new List<SCHALE.Common.FlatData.School>();
+    for (var _j = 0; _j < this.OpenConditionLength; ++_j) {_o.OpenCondition.Add(TableEncryptionService.Convert(this.OpenCondition(_j), key));}
+    _o.OpenConditionCount = new List<long>();
+    for (var _j = 0; _j < this.OpenConditionCountLength; ++_j) {_o.OpenConditionCount.Add(TableEncryptionService.Convert(this.OpenConditionCount(_j), key));}
+    _o.RewardParcelType = TableEncryptionService.Convert(this.RewardParcelType, key);
+    _o.RewardParcelId = TableEncryptionService.Convert(this.RewardParcelId, key);
+    _o.OpenTeacherRank = TableEncryptionService.Convert(this.OpenTeacherRank, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyLocationExcel> Pack(FlatBufferBuilder builder, AcademyLocationExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyLocationExcel>);
+    var _PrefabPath = _o.PrefabPath == null ? default(StringOffset) : builder.CreateString(_o.PrefabPath);
+    var _IconImagePath = _o.IconImagePath == null ? default(StringOffset) : builder.CreateString(_o.IconImagePath);
+    var _OpenCondition = default(VectorOffset);
+    if (_o.OpenCondition != null) {
+      var __OpenCondition = _o.OpenCondition.ToArray();
+      _OpenCondition = CreateOpenConditionVector(builder, __OpenCondition);
+    }
+    var _OpenConditionCount = default(VectorOffset);
+    if (_o.OpenConditionCount != null) {
+      var __OpenConditionCount = _o.OpenConditionCount.ToArray();
+      _OpenConditionCount = CreateOpenConditionCountVector(builder, __OpenConditionCount);
+    }
+    return CreateAcademyLocationExcel(
+      builder,
+      _o.Id,
+      _o.LocalizeEtcId,
+      _PrefabPath,
+      _IconImagePath,
+      _OpenCondition,
+      _OpenConditionCount,
+      _o.RewardParcelType,
+      _o.RewardParcelId,
+      _o.OpenTeacherRank);
+  }
+}
+
+public class AcademyLocationExcelT
+{
+  public long Id { get; set; }
+  public uint LocalizeEtcId { get; set; }
+  public string PrefabPath { get; set; }
+  public string IconImagePath { get; set; }
+  public List<SCHALE.Common.FlatData.School> OpenCondition { get; set; }
+  public List<long> OpenConditionCount { get; set; }
+  public SCHALE.Common.FlatData.ParcelType RewardParcelType { get; set; }
+  public long RewardParcelId { get; set; }
+  public long OpenTeacherRank { get; set; }
+
+  public AcademyLocationExcelT() {
+    this.Id = 0;
+    this.LocalizeEtcId = 0;
+    this.PrefabPath = null;
+    this.IconImagePath = null;
+    this.OpenCondition = null;
+    this.OpenConditionCount = null;
+    this.RewardParcelType = SCHALE.Common.FlatData.ParcelType.None;
+    this.RewardParcelId = 0;
+    this.OpenTeacherRank = 0;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyLocationExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyLocationExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct AcademyLocationExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyLocationExcelTable>(o);
   }
+  public AcademyLocationExcelTableT UnPack() {
+    var _o = new AcademyLocationExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyLocationExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyLocationExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.AcademyLocationExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyLocationExcelTable> Pack(FlatBufferBuilder builder, AcademyLocationExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyLocationExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.AcademyLocationExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.AcademyLocationExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAcademyLocationExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class AcademyLocationExcelTableT
+{
+  public List<SCHALE.Common.FlatData.AcademyLocationExcelT> DataList { get; set; }
+
+  public AcademyLocationExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyLocationRankExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyLocationRankExcel : IFlatbufferObject
@@ -42,6 +43,38 @@ public struct AcademyLocationRankExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyLocationRankExcel>(o);
   }
+  public AcademyLocationRankExcelT UnPack() {
+    var _o = new AcademyLocationRankExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyLocationRankExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyLocationRank");
+    _o.Rank = TableEncryptionService.Convert(this.Rank, key);
+    _o.RankExp = TableEncryptionService.Convert(this.RankExp, key);
+    _o.TotalExp = TableEncryptionService.Convert(this.TotalExp, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyLocationRankExcel> Pack(FlatBufferBuilder builder, AcademyLocationRankExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyLocationRankExcel>);
+    return CreateAcademyLocationRankExcel(
+      builder,
+      _o.Rank,
+      _o.RankExp,
+      _o.TotalExp);
+  }
+}
+
+public class AcademyLocationRankExcelT
+{
+  public long Rank { get; set; }
+  public long RankExp { get; set; }
+  public long TotalExp { get; set; }
+
+  public AcademyLocationRankExcelT() {
+    this.Rank = 0;
+    this.RankExp = 0;
+    this.TotalExp = 0;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyLocationRankExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyLocationRankExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct AcademyLocationRankExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyLocationRankExcelTable>(o);
   }
+  public AcademyLocationRankExcelTableT UnPack() {
+    var _o = new AcademyLocationRankExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyLocationRankExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyLocationRankExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.AcademyLocationRankExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyLocationRankExcelTable> Pack(FlatBufferBuilder builder, AcademyLocationRankExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyLocationRankExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.AcademyLocationRankExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.AcademyLocationRankExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAcademyLocationRankExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class AcademyLocationRankExcelTableT
+{
+  public List<SCHALE.Common.FlatData.AcademyLocationRankExcelT> DataList { get; set; }
+
+  public AcademyLocationRankExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyMessanger1Excel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyMessanger1Excel : IFlatbufferObject
@@ -104,6 +105,85 @@ public struct AcademyMessanger1Excel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyMessanger1Excel>(o);
   }
+  public AcademyMessanger1ExcelT UnPack() {
+    var _o = new AcademyMessanger1ExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyMessanger1ExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyMessanger1");
+    _o.MessageGroupId = TableEncryptionService.Convert(this.MessageGroupId, key);
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.CharacterId = TableEncryptionService.Convert(this.CharacterId, key);
+    _o.MessageCondition = TableEncryptionService.Convert(this.MessageCondition, key);
+    _o.ConditionValue = TableEncryptionService.Convert(this.ConditionValue, key);
+    _o.PreConditionGroupId = TableEncryptionService.Convert(this.PreConditionGroupId, key);
+    _o.PreConditionFavorScheduleId = TableEncryptionService.Convert(this.PreConditionFavorScheduleId, key);
+    _o.FavorScheduleId = TableEncryptionService.Convert(this.FavorScheduleId, key);
+    _o.NextGroupId = TableEncryptionService.Convert(this.NextGroupId, key);
+    _o.FeedbackTimeMillisec = TableEncryptionService.Convert(this.FeedbackTimeMillisec, key);
+    _o.MessageType = TableEncryptionService.Convert(this.MessageType, key);
+    _o.ImagePath = TableEncryptionService.Convert(this.ImagePath, key);
+    _o.MessageKR = TableEncryptionService.Convert(this.MessageKR, key);
+    _o.MessageJP = TableEncryptionService.Convert(this.MessageJP, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessanger1Excel> Pack(FlatBufferBuilder builder, AcademyMessanger1ExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyMessanger1Excel>);
+    var _ImagePath = _o.ImagePath == null ? default(StringOffset) : builder.CreateString(_o.ImagePath);
+    var _MessageKR = _o.MessageKR == null ? default(StringOffset) : builder.CreateString(_o.MessageKR);
+    var _MessageJP = _o.MessageJP == null ? default(StringOffset) : builder.CreateString(_o.MessageJP);
+    return CreateAcademyMessanger1Excel(
+      builder,
+      _o.MessageGroupId,
+      _o.Id,
+      _o.CharacterId,
+      _o.MessageCondition,
+      _o.ConditionValue,
+      _o.PreConditionGroupId,
+      _o.PreConditionFavorScheduleId,
+      _o.FavorScheduleId,
+      _o.NextGroupId,
+      _o.FeedbackTimeMillisec,
+      _o.MessageType,
+      _ImagePath,
+      _MessageKR,
+      _MessageJP);
+  }
+}
+
+public class AcademyMessanger1ExcelT
+{
+  public long MessageGroupId { get; set; }
+  public long Id { get; set; }
+  public long CharacterId { get; set; }
+  public SCHALE.Common.FlatData.AcademyMessageConditions MessageCondition { get; set; }
+  public long ConditionValue { get; set; }
+  public long PreConditionGroupId { get; set; }
+  public long PreConditionFavorScheduleId { get; set; }
+  public long FavorScheduleId { get; set; }
+  public long NextGroupId { get; set; }
+  public long FeedbackTimeMillisec { get; set; }
+  public SCHALE.Common.FlatData.AcademyMessageTypes MessageType { get; set; }
+  public string ImagePath { get; set; }
+  public string MessageKR { get; set; }
+  public string MessageJP { get; set; }
+
+  public AcademyMessanger1ExcelT() {
+    this.MessageGroupId = 0;
+    this.Id = 0;
+    this.CharacterId = 0;
+    this.MessageCondition = SCHALE.Common.FlatData.AcademyMessageConditions.None;
+    this.ConditionValue = 0;
+    this.PreConditionGroupId = 0;
+    this.PreConditionFavorScheduleId = 0;
+    this.FavorScheduleId = 0;
+    this.NextGroupId = 0;
+    this.FeedbackTimeMillisec = 0;
+    this.MessageType = SCHALE.Common.FlatData.AcademyMessageTypes.None;
+    this.ImagePath = null;
+    this.MessageKR = null;
+    this.MessageJP = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyMessanger1ExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyMessanger1ExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct AcademyMessanger1ExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyMessanger1ExcelTable>(o);
   }
+  public AcademyMessanger1ExcelTableT UnPack() {
+    var _o = new AcademyMessanger1ExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyMessanger1ExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyMessanger1Excel");
+    _o.DataList = new List<SCHALE.Common.FlatData.AcademyMessanger1ExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessanger1ExcelTable> Pack(FlatBufferBuilder builder, AcademyMessanger1ExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyMessanger1ExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.AcademyMessanger1Excel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.AcademyMessanger1Excel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAcademyMessanger1ExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class AcademyMessanger1ExcelTableT
+{
+  public List<SCHALE.Common.FlatData.AcademyMessanger1ExcelT> DataList { get; set; }
+
+  public AcademyMessanger1ExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyMessanger2Excel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyMessanger2Excel : IFlatbufferObject
@@ -104,6 +105,85 @@ public struct AcademyMessanger2Excel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyMessanger2Excel>(o);
   }
+  public AcademyMessanger2ExcelT UnPack() {
+    var _o = new AcademyMessanger2ExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyMessanger2ExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyMessanger2");
+    _o.MessageGroupId = TableEncryptionService.Convert(this.MessageGroupId, key);
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.CharacterId = TableEncryptionService.Convert(this.CharacterId, key);
+    _o.MessageCondition = TableEncryptionService.Convert(this.MessageCondition, key);
+    _o.ConditionValue = TableEncryptionService.Convert(this.ConditionValue, key);
+    _o.PreConditionGroupId = TableEncryptionService.Convert(this.PreConditionGroupId, key);
+    _o.PreConditionFavorScheduleId = TableEncryptionService.Convert(this.PreConditionFavorScheduleId, key);
+    _o.FavorScheduleId = TableEncryptionService.Convert(this.FavorScheduleId, key);
+    _o.NextGroupId = TableEncryptionService.Convert(this.NextGroupId, key);
+    _o.FeedbackTimeMillisec = TableEncryptionService.Convert(this.FeedbackTimeMillisec, key);
+    _o.MessageType = TableEncryptionService.Convert(this.MessageType, key);
+    _o.ImagePath = TableEncryptionService.Convert(this.ImagePath, key);
+    _o.MessageKR = TableEncryptionService.Convert(this.MessageKR, key);
+    _o.MessageJP = TableEncryptionService.Convert(this.MessageJP, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessanger2Excel> Pack(FlatBufferBuilder builder, AcademyMessanger2ExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyMessanger2Excel>);
+    var _ImagePath = _o.ImagePath == null ? default(StringOffset) : builder.CreateString(_o.ImagePath);
+    var _MessageKR = _o.MessageKR == null ? default(StringOffset) : builder.CreateString(_o.MessageKR);
+    var _MessageJP = _o.MessageJP == null ? default(StringOffset) : builder.CreateString(_o.MessageJP);
+    return CreateAcademyMessanger2Excel(
+      builder,
+      _o.MessageGroupId,
+      _o.Id,
+      _o.CharacterId,
+      _o.MessageCondition,
+      _o.ConditionValue,
+      _o.PreConditionGroupId,
+      _o.PreConditionFavorScheduleId,
+      _o.FavorScheduleId,
+      _o.NextGroupId,
+      _o.FeedbackTimeMillisec,
+      _o.MessageType,
+      _ImagePath,
+      _MessageKR,
+      _MessageJP);
+  }
+}
+
+public class AcademyMessanger2ExcelT
+{
+  public long MessageGroupId { get; set; }
+  public long Id { get; set; }
+  public long CharacterId { get; set; }
+  public SCHALE.Common.FlatData.AcademyMessageConditions MessageCondition { get; set; }
+  public long ConditionValue { get; set; }
+  public long PreConditionGroupId { get; set; }
+  public long PreConditionFavorScheduleId { get; set; }
+  public long FavorScheduleId { get; set; }
+  public long NextGroupId { get; set; }
+  public long FeedbackTimeMillisec { get; set; }
+  public SCHALE.Common.FlatData.AcademyMessageTypes MessageType { get; set; }
+  public string ImagePath { get; set; }
+  public string MessageKR { get; set; }
+  public string MessageJP { get; set; }
+
+  public AcademyMessanger2ExcelT() {
+    this.MessageGroupId = 0;
+    this.Id = 0;
+    this.CharacterId = 0;
+    this.MessageCondition = SCHALE.Common.FlatData.AcademyMessageConditions.None;
+    this.ConditionValue = 0;
+    this.PreConditionGroupId = 0;
+    this.PreConditionFavorScheduleId = 0;
+    this.FavorScheduleId = 0;
+    this.NextGroupId = 0;
+    this.FeedbackTimeMillisec = 0;
+    this.MessageType = SCHALE.Common.FlatData.AcademyMessageTypes.None;
+    this.ImagePath = null;
+    this.MessageKR = null;
+    this.MessageJP = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyMessanger2ExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyMessanger2ExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct AcademyMessanger2ExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyMessanger2ExcelTable>(o);
   }
+  public AcademyMessanger2ExcelTableT UnPack() {
+    var _o = new AcademyMessanger2ExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyMessanger2ExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyMessanger2Excel");
+    _o.DataList = new List<SCHALE.Common.FlatData.AcademyMessanger2ExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessanger2ExcelTable> Pack(FlatBufferBuilder builder, AcademyMessanger2ExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyMessanger2ExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.AcademyMessanger2Excel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.AcademyMessanger2Excel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAcademyMessanger2ExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class AcademyMessanger2ExcelTableT
+{
+  public List<SCHALE.Common.FlatData.AcademyMessanger2ExcelT> DataList { get; set; }
+
+  public AcademyMessanger2ExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyMessanger3Excel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyMessanger3Excel : IFlatbufferObject
@@ -104,6 +105,85 @@ public struct AcademyMessanger3Excel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyMessanger3Excel>(o);
   }
+  public AcademyMessanger3ExcelT UnPack() {
+    var _o = new AcademyMessanger3ExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyMessanger3ExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyMessanger3");
+    _o.MessageGroupId = TableEncryptionService.Convert(this.MessageGroupId, key);
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.CharacterId = TableEncryptionService.Convert(this.CharacterId, key);
+    _o.MessageCondition = TableEncryptionService.Convert(this.MessageCondition, key);
+    _o.ConditionValue = TableEncryptionService.Convert(this.ConditionValue, key);
+    _o.PreConditionGroupId = TableEncryptionService.Convert(this.PreConditionGroupId, key);
+    _o.PreConditionFavorScheduleId = TableEncryptionService.Convert(this.PreConditionFavorScheduleId, key);
+    _o.FavorScheduleId = TableEncryptionService.Convert(this.FavorScheduleId, key);
+    _o.NextGroupId = TableEncryptionService.Convert(this.NextGroupId, key);
+    _o.FeedbackTimeMillisec = TableEncryptionService.Convert(this.FeedbackTimeMillisec, key);
+    _o.MessageType = TableEncryptionService.Convert(this.MessageType, key);
+    _o.ImagePath = TableEncryptionService.Convert(this.ImagePath, key);
+    _o.MessageKR = TableEncryptionService.Convert(this.MessageKR, key);
+    _o.MessageJP = TableEncryptionService.Convert(this.MessageJP, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessanger3Excel> Pack(FlatBufferBuilder builder, AcademyMessanger3ExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyMessanger3Excel>);
+    var _ImagePath = _o.ImagePath == null ? default(StringOffset) : builder.CreateString(_o.ImagePath);
+    var _MessageKR = _o.MessageKR == null ? default(StringOffset) : builder.CreateString(_o.MessageKR);
+    var _MessageJP = _o.MessageJP == null ? default(StringOffset) : builder.CreateString(_o.MessageJP);
+    return CreateAcademyMessanger3Excel(
+      builder,
+      _o.MessageGroupId,
+      _o.Id,
+      _o.CharacterId,
+      _o.MessageCondition,
+      _o.ConditionValue,
+      _o.PreConditionGroupId,
+      _o.PreConditionFavorScheduleId,
+      _o.FavorScheduleId,
+      _o.NextGroupId,
+      _o.FeedbackTimeMillisec,
+      _o.MessageType,
+      _ImagePath,
+      _MessageKR,
+      _MessageJP);
+  }
+}
+
+public class AcademyMessanger3ExcelT
+{
+  public long MessageGroupId { get; set; }
+  public long Id { get; set; }
+  public long CharacterId { get; set; }
+  public SCHALE.Common.FlatData.AcademyMessageConditions MessageCondition { get; set; }
+  public long ConditionValue { get; set; }
+  public long PreConditionGroupId { get; set; }
+  public long PreConditionFavorScheduleId { get; set; }
+  public long FavorScheduleId { get; set; }
+  public long NextGroupId { get; set; }
+  public long FeedbackTimeMillisec { get; set; }
+  public SCHALE.Common.FlatData.AcademyMessageTypes MessageType { get; set; }
+  public string ImagePath { get; set; }
+  public string MessageKR { get; set; }
+  public string MessageJP { get; set; }
+
+  public AcademyMessanger3ExcelT() {
+    this.MessageGroupId = 0;
+    this.Id = 0;
+    this.CharacterId = 0;
+    this.MessageCondition = SCHALE.Common.FlatData.AcademyMessageConditions.None;
+    this.ConditionValue = 0;
+    this.PreConditionGroupId = 0;
+    this.PreConditionFavorScheduleId = 0;
+    this.FavorScheduleId = 0;
+    this.NextGroupId = 0;
+    this.FeedbackTimeMillisec = 0;
+    this.MessageType = SCHALE.Common.FlatData.AcademyMessageTypes.None;
+    this.ImagePath = null;
+    this.MessageKR = null;
+    this.MessageJP = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyMessanger3ExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyMessanger3ExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct AcademyMessanger3ExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyMessanger3ExcelTable>(o);
   }
+  public AcademyMessanger3ExcelTableT UnPack() {
+    var _o = new AcademyMessanger3ExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyMessanger3ExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyMessanger3Excel");
+    _o.DataList = new List<SCHALE.Common.FlatData.AcademyMessanger3ExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessanger3ExcelTable> Pack(FlatBufferBuilder builder, AcademyMessanger3ExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyMessanger3ExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.AcademyMessanger3Excel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.AcademyMessanger3Excel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAcademyMessanger3ExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class AcademyMessanger3ExcelTableT
+{
+  public List<SCHALE.Common.FlatData.AcademyMessanger3ExcelT> DataList { get; set; }
+
+  public AcademyMessanger3ExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyMessangerExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyMessangerExcel : IFlatbufferObject
@@ -104,6 +105,85 @@ public struct AcademyMessangerExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyMessangerExcel>(o);
   }
+  public AcademyMessangerExcelT UnPack() {
+    var _o = new AcademyMessangerExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyMessangerExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyMessanger");
+    _o.MessageGroupId = TableEncryptionService.Convert(this.MessageGroupId, key);
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.CharacterId = TableEncryptionService.Convert(this.CharacterId, key);
+    _o.MessageCondition = TableEncryptionService.Convert(this.MessageCondition, key);
+    _o.ConditionValue = TableEncryptionService.Convert(this.ConditionValue, key);
+    _o.PreConditionGroupId = TableEncryptionService.Convert(this.PreConditionGroupId, key);
+    _o.PreConditionFavorScheduleId = TableEncryptionService.Convert(this.PreConditionFavorScheduleId, key);
+    _o.FavorScheduleId = TableEncryptionService.Convert(this.FavorScheduleId, key);
+    _o.NextGroupId = TableEncryptionService.Convert(this.NextGroupId, key);
+    _o.FeedbackTimeMillisec = TableEncryptionService.Convert(this.FeedbackTimeMillisec, key);
+    _o.MessageType = TableEncryptionService.Convert(this.MessageType, key);
+    _o.ImagePath = TableEncryptionService.Convert(this.ImagePath, key);
+    _o.MessageKR = TableEncryptionService.Convert(this.MessageKR, key);
+    _o.MessageJP = TableEncryptionService.Convert(this.MessageJP, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessangerExcel> Pack(FlatBufferBuilder builder, AcademyMessangerExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyMessangerExcel>);
+    var _ImagePath = _o.ImagePath == null ? default(StringOffset) : builder.CreateString(_o.ImagePath);
+    var _MessageKR = _o.MessageKR == null ? default(StringOffset) : builder.CreateString(_o.MessageKR);
+    var _MessageJP = _o.MessageJP == null ? default(StringOffset) : builder.CreateString(_o.MessageJP);
+    return CreateAcademyMessangerExcel(
+      builder,
+      _o.MessageGroupId,
+      _o.Id,
+      _o.CharacterId,
+      _o.MessageCondition,
+      _o.ConditionValue,
+      _o.PreConditionGroupId,
+      _o.PreConditionFavorScheduleId,
+      _o.FavorScheduleId,
+      _o.NextGroupId,
+      _o.FeedbackTimeMillisec,
+      _o.MessageType,
+      _ImagePath,
+      _MessageKR,
+      _MessageJP);
+  }
+}
+
+public class AcademyMessangerExcelT
+{
+  public long MessageGroupId { get; set; }
+  public long Id { get; set; }
+  public long CharacterId { get; set; }
+  public SCHALE.Common.FlatData.AcademyMessageConditions MessageCondition { get; set; }
+  public long ConditionValue { get; set; }
+  public long PreConditionGroupId { get; set; }
+  public long PreConditionFavorScheduleId { get; set; }
+  public long FavorScheduleId { get; set; }
+  public long NextGroupId { get; set; }
+  public long FeedbackTimeMillisec { get; set; }
+  public SCHALE.Common.FlatData.AcademyMessageTypes MessageType { get; set; }
+  public string ImagePath { get; set; }
+  public string MessageKR { get; set; }
+  public string MessageJP { get; set; }
+
+  public AcademyMessangerExcelT() {
+    this.MessageGroupId = 0;
+    this.Id = 0;
+    this.CharacterId = 0;
+    this.MessageCondition = SCHALE.Common.FlatData.AcademyMessageConditions.None;
+    this.ConditionValue = 0;
+    this.PreConditionGroupId = 0;
+    this.PreConditionFavorScheduleId = 0;
+    this.FavorScheduleId = 0;
+    this.NextGroupId = 0;
+    this.FeedbackTimeMillisec = 0;
+    this.MessageType = SCHALE.Common.FlatData.AcademyMessageTypes.None;
+    this.ImagePath = null;
+    this.MessageKR = null;
+    this.MessageJP = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyMessangerExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyMessangerExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct AcademyMessangerExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyMessangerExcelTable>(o);
   }
+  public AcademyMessangerExcelTableT UnPack() {
+    var _o = new AcademyMessangerExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyMessangerExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyMessangerExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.AcademyMessangerExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessangerExcelTable> Pack(FlatBufferBuilder builder, AcademyMessangerExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyMessangerExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.AcademyMessangerExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.AcademyMessangerExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAcademyMessangerExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class AcademyMessangerExcelTableT
+{
+  public List<SCHALE.Common.FlatData.AcademyMessangerExcelT> DataList { get; set; }
+
+  public AcademyMessangerExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyRewardExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyRewardExcel : IFlatbufferObject
@@ -218,6 +219,156 @@ public struct AcademyRewardExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyRewardExcel>(o);
   }
+  public AcademyRewardExcelT UnPack() {
+    var _o = new AcademyRewardExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyRewardExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyReward");
+    _o.Location = TableEncryptionService.Convert(this.Location, key);
+    _o.ScheduleGroupId = TableEncryptionService.Convert(this.ScheduleGroupId, key);
+    _o.OrderInGroup = TableEncryptionService.Convert(this.OrderInGroup, key);
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.ProgressTexture = TableEncryptionService.Convert(this.ProgressTexture, key);
+    _o.LocalizeEtcId = TableEncryptionService.Convert(this.LocalizeEtcId, key);
+    _o.LocationRank = TableEncryptionService.Convert(this.LocationRank, key);
+    _o.FavorExp = TableEncryptionService.Convert(this.FavorExp, key);
+    _o.SecretStoneAmount = TableEncryptionService.Convert(this.SecretStoneAmount, key);
+    _o.SecretStoneProb = TableEncryptionService.Convert(this.SecretStoneProb, key);
+    _o.ExtraFavorExp = TableEncryptionService.Convert(this.ExtraFavorExp, key);
+    _o.ExtraFavorExpProb = TableEncryptionService.Convert(this.ExtraFavorExpProb, key);
+    _o.ExtraRewardParcelType = new List<SCHALE.Common.FlatData.ParcelType>();
+    for (var _j = 0; _j < this.ExtraRewardParcelTypeLength; ++_j) {_o.ExtraRewardParcelType.Add(TableEncryptionService.Convert(this.ExtraRewardParcelType(_j), key));}
+    _o.ExtraRewardParcelId = new List<long>();
+    for (var _j = 0; _j < this.ExtraRewardParcelIdLength; ++_j) {_o.ExtraRewardParcelId.Add(TableEncryptionService.Convert(this.ExtraRewardParcelId(_j), key));}
+    _o.ExtraRewardAmount = new List<long>();
+    for (var _j = 0; _j < this.ExtraRewardAmountLength; ++_j) {_o.ExtraRewardAmount.Add(TableEncryptionService.Convert(this.ExtraRewardAmount(_j), key));}
+    _o.ExtraRewardProb = new List<long>();
+    for (var _j = 0; _j < this.ExtraRewardProbLength; ++_j) {_o.ExtraRewardProb.Add(TableEncryptionService.Convert(this.ExtraRewardProb(_j), key));}
+    _o.IsExtraRewardDisplayed = new List<bool>();
+    for (var _j = 0; _j < this.IsExtraRewardDisplayedLength; ++_j) {_o.IsExtraRewardDisplayed.Add(TableEncryptionService.Convert(this.IsExtraRewardDisplayed(_j), key));}
+    _o.RewardParcelType = new List<SCHALE.Common.FlatData.ParcelType>();
+    for (var _j = 0; _j < this.RewardParcelTypeLength; ++_j) {_o.RewardParcelType.Add(TableEncryptionService.Convert(this.RewardParcelType(_j), key));}
+    _o.RewardParcelId = new List<long>();
+    for (var _j = 0; _j < this.RewardParcelIdLength; ++_j) {_o.RewardParcelId.Add(TableEncryptionService.Convert(this.RewardParcelId(_j), key));}
+    _o.RewardAmount = new List<long>();
+    for (var _j = 0; _j < this.RewardAmountLength; ++_j) {_o.RewardAmount.Add(TableEncryptionService.Convert(this.RewardAmount(_j), key));}
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyRewardExcel> Pack(FlatBufferBuilder builder, AcademyRewardExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyRewardExcel>);
+    var _Location = _o.Location == null ? default(StringOffset) : builder.CreateString(_o.Location);
+    var _ProgressTexture = _o.ProgressTexture == null ? default(StringOffset) : builder.CreateString(_o.ProgressTexture);
+    var _ExtraRewardParcelType = default(VectorOffset);
+    if (_o.ExtraRewardParcelType != null) {
+      var __ExtraRewardParcelType = _o.ExtraRewardParcelType.ToArray();
+      _ExtraRewardParcelType = CreateExtraRewardParcelTypeVector(builder, __ExtraRewardParcelType);
+    }
+    var _ExtraRewardParcelId = default(VectorOffset);
+    if (_o.ExtraRewardParcelId != null) {
+      var __ExtraRewardParcelId = _o.ExtraRewardParcelId.ToArray();
+      _ExtraRewardParcelId = CreateExtraRewardParcelIdVector(builder, __ExtraRewardParcelId);
+    }
+    var _ExtraRewardAmount = default(VectorOffset);
+    if (_o.ExtraRewardAmount != null) {
+      var __ExtraRewardAmount = _o.ExtraRewardAmount.ToArray();
+      _ExtraRewardAmount = CreateExtraRewardAmountVector(builder, __ExtraRewardAmount);
+    }
+    var _ExtraRewardProb = default(VectorOffset);
+    if (_o.ExtraRewardProb != null) {
+      var __ExtraRewardProb = _o.ExtraRewardProb.ToArray();
+      _ExtraRewardProb = CreateExtraRewardProbVector(builder, __ExtraRewardProb);
+    }
+    var _IsExtraRewardDisplayed = default(VectorOffset);
+    if (_o.IsExtraRewardDisplayed != null) {
+      var __IsExtraRewardDisplayed = _o.IsExtraRewardDisplayed.ToArray();
+      _IsExtraRewardDisplayed = CreateIsExtraRewardDisplayedVector(builder, __IsExtraRewardDisplayed);
+    }
+    var _RewardParcelType = default(VectorOffset);
+    if (_o.RewardParcelType != null) {
+      var __RewardParcelType = _o.RewardParcelType.ToArray();
+      _RewardParcelType = CreateRewardParcelTypeVector(builder, __RewardParcelType);
+    }
+    var _RewardParcelId = default(VectorOffset);
+    if (_o.RewardParcelId != null) {
+      var __RewardParcelId = _o.RewardParcelId.ToArray();
+      _RewardParcelId = CreateRewardParcelIdVector(builder, __RewardParcelId);
+    }
+    var _RewardAmount = default(VectorOffset);
+    if (_o.RewardAmount != null) {
+      var __RewardAmount = _o.RewardAmount.ToArray();
+      _RewardAmount = CreateRewardAmountVector(builder, __RewardAmount);
+    }
+    return CreateAcademyRewardExcel(
+      builder,
+      _Location,
+      _o.ScheduleGroupId,
+      _o.OrderInGroup,
+      _o.Id,
+      _ProgressTexture,
+      _o.LocalizeEtcId,
+      _o.LocationRank,
+      _o.FavorExp,
+      _o.SecretStoneAmount,
+      _o.SecretStoneProb,
+      _o.ExtraFavorExp,
+      _o.ExtraFavorExpProb,
+      _ExtraRewardParcelType,
+      _ExtraRewardParcelId,
+      _ExtraRewardAmount,
+      _ExtraRewardProb,
+      _IsExtraRewardDisplayed,
+      _RewardParcelType,
+      _RewardParcelId,
+      _RewardAmount);
+  }
+}
+
+public class AcademyRewardExcelT
+{
+  public string Location { get; set; }
+  public long ScheduleGroupId { get; set; }
+  public long OrderInGroup { get; set; }
+  public long Id { get; set; }
+  public string ProgressTexture { get; set; }
+  public uint LocalizeEtcId { get; set; }
+  public long LocationRank { get; set; }
+  public long FavorExp { get; set; }
+  public long SecretStoneAmount { get; set; }
+  public long SecretStoneProb { get; set; }
+  public long ExtraFavorExp { get; set; }
+  public long ExtraFavorExpProb { get; set; }
+  public List<SCHALE.Common.FlatData.ParcelType> ExtraRewardParcelType { get; set; }
+  public List<long> ExtraRewardParcelId { get; set; }
+  public List<long> ExtraRewardAmount { get; set; }
+  public List<long> ExtraRewardProb { get; set; }
+  public List<bool> IsExtraRewardDisplayed { get; set; }
+  public List<SCHALE.Common.FlatData.ParcelType> RewardParcelType { get; set; }
+  public List<long> RewardParcelId { get; set; }
+  public List<long> RewardAmount { get; set; }
+
+  public AcademyRewardExcelT() {
+    this.Location = null;
+    this.ScheduleGroupId = 0;
+    this.OrderInGroup = 0;
+    this.Id = 0;
+    this.ProgressTexture = null;
+    this.LocalizeEtcId = 0;
+    this.LocationRank = 0;
+    this.FavorExp = 0;
+    this.SecretStoneAmount = 0;
+    this.SecretStoneProb = 0;
+    this.ExtraFavorExp = 0;
+    this.ExtraFavorExpProb = 0;
+    this.ExtraRewardParcelType = null;
+    this.ExtraRewardParcelId = null;
+    this.ExtraRewardAmount = null;
+    this.ExtraRewardProb = null;
+    this.IsExtraRewardDisplayed = null;
+    this.RewardParcelType = null;
+    this.RewardParcelId = null;
+    this.RewardAmount = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyRewardExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyRewardExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct AcademyRewardExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyRewardExcelTable>(o);
   }
+  public AcademyRewardExcelTableT UnPack() {
+    var _o = new AcademyRewardExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyRewardExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyRewardExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.AcademyRewardExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyRewardExcelTable> Pack(FlatBufferBuilder builder, AcademyRewardExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyRewardExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.AcademyRewardExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.AcademyRewardExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAcademyRewardExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class AcademyRewardExcelTableT
+{
+  public List<SCHALE.Common.FlatData.AcademyRewardExcelT> DataList { get; set; }
+
+  public AcademyRewardExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyTicketExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyTicketExcel : IFlatbufferObject
@@ -38,6 +39,34 @@ public struct AcademyTicketExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyTicketExcel>(o);
   }
+  public AcademyTicketExcelT UnPack() {
+    var _o = new AcademyTicketExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyTicketExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyTicket");
+    _o.LocationRankSum = TableEncryptionService.Convert(this.LocationRankSum, key);
+    _o.ScheduleTicktetMax = TableEncryptionService.Convert(this.ScheduleTicktetMax, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyTicketExcel> Pack(FlatBufferBuilder builder, AcademyTicketExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyTicketExcel>);
+    return CreateAcademyTicketExcel(
+      builder,
+      _o.LocationRankSum,
+      _o.ScheduleTicktetMax);
+  }
+}
+
+public class AcademyTicketExcelT
+{
+  public long LocationRankSum { get; set; }
+  public long ScheduleTicktetMax { get; set; }
+
+  public AcademyTicketExcelT() {
+    this.LocationRankSum = 0;
+    this.ScheduleTicktetMax = 0;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyTicketExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyTicketExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct AcademyTicketExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyTicketExcelTable>(o);
   }
+  public AcademyTicketExcelTableT UnPack() {
+    var _o = new AcademyTicketExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyTicketExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyTicketExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.AcademyTicketExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyTicketExcelTable> Pack(FlatBufferBuilder builder, AcademyTicketExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyTicketExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.AcademyTicketExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.AcademyTicketExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAcademyTicketExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class AcademyTicketExcelTableT
+{
+  public List<SCHALE.Common.FlatData.AcademyTicketExcelT> DataList { get; set; }
+
+  public AcademyTicketExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyZoneExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyZoneExcel : IFlatbufferObject
@@ -82,6 +83,66 @@ public struct AcademyZoneExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyZoneExcel>(o);
   }
+  public AcademyZoneExcelT UnPack() {
+    var _o = new AcademyZoneExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyZoneExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyZone");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.LocationId = TableEncryptionService.Convert(this.LocationId, key);
+    _o.LocationRankForUnlock = TableEncryptionService.Convert(this.LocationRankForUnlock, key);
+    _o.LocalizeEtcId = TableEncryptionService.Convert(this.LocalizeEtcId, key);
+    _o.StudentVisitProb = new List<long>();
+    for (var _j = 0; _j < this.StudentVisitProbLength; ++_j) {_o.StudentVisitProb.Add(TableEncryptionService.Convert(this.StudentVisitProb(_j), key));}
+    _o.RewardGroupId = TableEncryptionService.Convert(this.RewardGroupId, key);
+    _o.Tags = new List<SCHALE.Common.FlatData.Tag>();
+    for (var _j = 0; _j < this.TagsLength; ++_j) {_o.Tags.Add(TableEncryptionService.Convert(this.Tags(_j), key));}
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyZoneExcel> Pack(FlatBufferBuilder builder, AcademyZoneExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyZoneExcel>);
+    var _StudentVisitProb = default(VectorOffset);
+    if (_o.StudentVisitProb != null) {
+      var __StudentVisitProb = _o.StudentVisitProb.ToArray();
+      _StudentVisitProb = CreateStudentVisitProbVector(builder, __StudentVisitProb);
+    }
+    var _Tags = default(VectorOffset);
+    if (_o.Tags != null) {
+      var __Tags = _o.Tags.ToArray();
+      _Tags = CreateTagsVector(builder, __Tags);
+    }
+    return CreateAcademyZoneExcel(
+      builder,
+      _o.Id,
+      _o.LocationId,
+      _o.LocationRankForUnlock,
+      _o.LocalizeEtcId,
+      _StudentVisitProb,
+      _o.RewardGroupId,
+      _Tags);
+  }
+}
+
+public class AcademyZoneExcelT
+{
+  public long Id { get; set; }
+  public long LocationId { get; set; }
+  public long LocationRankForUnlock { get; set; }
+  public uint LocalizeEtcId { get; set; }
+  public List<long> StudentVisitProb { get; set; }
+  public long RewardGroupId { get; set; }
+  public List<SCHALE.Common.FlatData.Tag> Tags { get; set; }
+
+  public AcademyZoneExcelT() {
+    this.Id = 0;
+    this.LocationId = 0;
+    this.LocationRankForUnlock = 0;
+    this.LocalizeEtcId = 0;
+    this.StudentVisitProb = null;
+    this.RewardGroupId = 0;
+    this.Tags = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AcademyZoneExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AcademyZoneExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct AcademyZoneExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AcademyZoneExcelTable>(o);
   }
+  public AcademyZoneExcelTableT UnPack() {
+    var _o = new AcademyZoneExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AcademyZoneExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AcademyZoneExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.AcademyZoneExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AcademyZoneExcelTable> Pack(FlatBufferBuilder builder, AcademyZoneExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AcademyZoneExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.AcademyZoneExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.AcademyZoneExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAcademyZoneExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class AcademyZoneExcelTableT
+{
+  public List<SCHALE.Common.FlatData.AcademyZoneExcelT> DataList { get; set; }
+
+  public AcademyZoneExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AccountLevelExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AccountLevelExcel : IFlatbufferObject
@@ -50,6 +51,46 @@ public struct AccountLevelExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AccountLevelExcel>(o);
   }
+  public AccountLevelExcelT UnPack() {
+    var _o = new AccountLevelExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AccountLevelExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AccountLevel");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.Level = TableEncryptionService.Convert(this.Level, key);
+    _o.Exp = TableEncryptionService.Convert(this.Exp, key);
+    _o.APAutoChargeMax = TableEncryptionService.Convert(this.APAutoChargeMax, key);
+    _o.NeedReportEvent = TableEncryptionService.Convert(this.NeedReportEvent, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.AccountLevelExcel> Pack(FlatBufferBuilder builder, AccountLevelExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AccountLevelExcel>);
+    return CreateAccountLevelExcel(
+      builder,
+      _o.Id,
+      _o.Level,
+      _o.Exp,
+      _o.APAutoChargeMax,
+      _o.NeedReportEvent);
+  }
+}
+
+public class AccountLevelExcelT
+{
+  public long Id { get; set; }
+  public long Level { get; set; }
+  public long Exp { get; set; }
+  public long APAutoChargeMax { get; set; }
+  public bool NeedReportEvent { get; set; }
+
+  public AccountLevelExcelT() {
+    this.Id = 0;
+    this.Level = 0;
+    this.Exp = 0;
+    this.APAutoChargeMax = 0;
+    this.NeedReportEvent = false;
+  }
 }
 
 

SCHALE.Common/FlatData/AccountLevelExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AccountLevelExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct AccountLevelExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AccountLevelExcelTable>(o);
   }
+  public AccountLevelExcelTableT UnPack() {
+    var _o = new AccountLevelExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AccountLevelExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AccountLevelExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.AccountLevelExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AccountLevelExcelTable> Pack(FlatBufferBuilder builder, AccountLevelExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AccountLevelExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.AccountLevelExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.AccountLevelExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAccountLevelExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class AccountLevelExcelTableT
+{
+  public List<SCHALE.Common.FlatData.AccountLevelExcelT> DataList { get; set; }
+
+  public AccountLevelExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AniEventData.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AniEventData : IFlatbufferObject
@@ -62,6 +63,48 @@ public struct AniEventData : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AniEventData>(o);
   }
+  public AniEventDataT UnPack() {
+    var _o = new AniEventDataT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AniEventDataT _o) {
+		byte[] key = { 0 };
+    _o.Name = TableEncryptionService.Convert(this.Name, key);
+    _o.Time = TableEncryptionService.Convert(this.Time, key);
+    _o.IntParam = TableEncryptionService.Convert(this.IntParam, key);
+    _o.FloatParam = TableEncryptionService.Convert(this.FloatParam, key);
+    _o.StringParam = TableEncryptionService.Convert(this.StringParam, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.AniEventData> Pack(FlatBufferBuilder builder, AniEventDataT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AniEventData>);
+    var _Name = _o.Name == null ? default(StringOffset) : builder.CreateString(_o.Name);
+    var _StringParam = _o.StringParam == null ? default(StringOffset) : builder.CreateString(_o.StringParam);
+    return CreateAniEventData(
+      builder,
+      _Name,
+      _o.Time,
+      _o.IntParam,
+      _o.FloatParam,
+      _StringParam);
+  }
+}
+
+public class AniEventDataT
+{
+  public string Name { get; set; }
+  public float Time { get; set; }
+  public int IntParam { get; set; }
+  public float FloatParam { get; set; }
+  public string StringParam { get; set; }
+
+  public AniEventDataT() {
+    this.Name = null;
+    this.Time = 0.0f;
+    this.IntParam = 0;
+    this.FloatParam = 0.0f;
+    this.StringParam = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AniStateData.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AniStateData : IFlatbufferObject
@@ -120,6 +121,87 @@ public struct AniStateData : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AniStateData>(o);
   }
+  public AniStateDataT UnPack() {
+    var _o = new AniStateDataT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AniStateDataT _o) {
+		byte[] key = { 0 };
+    _o.StateName = TableEncryptionService.Convert(this.StateName, key);
+    _o.StatePrefix = TableEncryptionService.Convert(this.StatePrefix, key);
+    _o.StateNameWithPrefix = TableEncryptionService.Convert(this.StateNameWithPrefix, key);
+    _o.Tag = TableEncryptionService.Convert(this.Tag, key);
+    _o.SpeedParameterName = TableEncryptionService.Convert(this.SpeedParameterName, key);
+    _o.SpeedParamter = TableEncryptionService.Convert(this.SpeedParamter, key);
+    _o.StateSpeed = TableEncryptionService.Convert(this.StateSpeed, key);
+    _o.ClipName = TableEncryptionService.Convert(this.ClipName, key);
+    _o.Length = TableEncryptionService.Convert(this.Length, key);
+    _o.FrameRate = TableEncryptionService.Convert(this.FrameRate, key);
+    _o.IsLooping = TableEncryptionService.Convert(this.IsLooping, key);
+    _o.Events = new List<SCHALE.Common.FlatData.AniEventDataT>();
+    for (var _j = 0; _j < this.EventsLength; ++_j) {_o.Events.Add(this.Events(_j).HasValue ? this.Events(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AniStateData> Pack(FlatBufferBuilder builder, AniStateDataT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AniStateData>);
+    var _StateName = _o.StateName == null ? default(StringOffset) : builder.CreateString(_o.StateName);
+    var _StatePrefix = _o.StatePrefix == null ? default(StringOffset) : builder.CreateString(_o.StatePrefix);
+    var _StateNameWithPrefix = _o.StateNameWithPrefix == null ? default(StringOffset) : builder.CreateString(_o.StateNameWithPrefix);
+    var _Tag = _o.Tag == null ? default(StringOffset) : builder.CreateString(_o.Tag);
+    var _SpeedParameterName = _o.SpeedParameterName == null ? default(StringOffset) : builder.CreateString(_o.SpeedParameterName);
+    var _ClipName = _o.ClipName == null ? default(StringOffset) : builder.CreateString(_o.ClipName);
+    var _Events = default(VectorOffset);
+    if (_o.Events != null) {
+      var __Events = new Offset<SCHALE.Common.FlatData.AniEventData>[_o.Events.Count];
+      for (var _j = 0; _j < __Events.Length; ++_j) { __Events[_j] = SCHALE.Common.FlatData.AniEventData.Pack(builder, _o.Events[_j]); }
+      _Events = CreateEventsVector(builder, __Events);
+    }
+    return CreateAniStateData(
+      builder,
+      _StateName,
+      _StatePrefix,
+      _StateNameWithPrefix,
+      _Tag,
+      _SpeedParameterName,
+      _o.SpeedParamter,
+      _o.StateSpeed,
+      _ClipName,
+      _o.Length,
+      _o.FrameRate,
+      _o.IsLooping,
+      _Events);
+  }
+}
+
+public class AniStateDataT
+{
+  public string StateName { get; set; }
+  public string StatePrefix { get; set; }
+  public string StateNameWithPrefix { get; set; }
+  public string Tag { get; set; }
+  public string SpeedParameterName { get; set; }
+  public float SpeedParamter { get; set; }
+  public float StateSpeed { get; set; }
+  public string ClipName { get; set; }
+  public float Length { get; set; }
+  public float FrameRate { get; set; }
+  public bool IsLooping { get; set; }
+  public List<SCHALE.Common.FlatData.AniEventDataT> Events { get; set; }
+
+  public AniStateDataT() {
+    this.StateName = null;
+    this.StatePrefix = null;
+    this.StateNameWithPrefix = null;
+    this.Tag = null;
+    this.SpeedParameterName = null;
+    this.SpeedParamter = 0.0f;
+    this.StateSpeed = 0.0f;
+    this.ClipName = null;
+    this.Length = 0.0f;
+    this.FrameRate = 0.0f;
+    this.IsLooping = false;
+    this.Events = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AnimationBlendTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AnimationBlendTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct AnimationBlendTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AnimationBlendTable>(o);
   }
+  public AnimationBlendTableT UnPack() {
+    var _o = new AnimationBlendTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AnimationBlendTableT _o) {
+		byte[] key = { 0 };
+    _o.DataList = new List<SCHALE.Common.FlatData.BlendDataT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AnimationBlendTable> Pack(FlatBufferBuilder builder, AnimationBlendTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AnimationBlendTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.BlendData>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.BlendData.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAnimationBlendTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class AnimationBlendTableT
+{
+  public List<SCHALE.Common.FlatData.BlendDataT> DataList { get; set; }
+
+  public AnimationBlendTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AnimatorData.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AnimatorData : IFlatbufferObject
@@ -60,6 +61,47 @@ public struct AnimatorData : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AnimatorData>(o);
   }
+  public AnimatorDataT UnPack() {
+    var _o = new AnimatorDataT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AnimatorDataT _o) {
+		byte[] key = { 0 };
+    _o.DefaultStateName = TableEncryptionService.Convert(this.DefaultStateName, key);
+    _o.Name = TableEncryptionService.Convert(this.Name, key);
+    _o.DataList = new List<SCHALE.Common.FlatData.AniStateDataT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AnimatorData> Pack(FlatBufferBuilder builder, AnimatorDataT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AnimatorData>);
+    var _DefaultStateName = _o.DefaultStateName == null ? default(StringOffset) : builder.CreateString(_o.DefaultStateName);
+    var _Name = _o.Name == null ? default(StringOffset) : builder.CreateString(_o.Name);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.AniStateData>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.AniStateData.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAnimatorData(
+      builder,
+      _DefaultStateName,
+      _Name,
+      _DataList);
+  }
+}
+
+public class AnimatorDataT
+{
+  public string DefaultStateName { get; set; }
+  public string Name { get; set; }
+  public List<SCHALE.Common.FlatData.AniStateDataT> DataList { get; set; }
+
+  public AnimatorDataT() {
+    this.DefaultStateName = null;
+    this.Name = null;
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AnimatorDataTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AnimatorDataTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct AnimatorDataTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AnimatorDataTable>(o);
   }
+  public AnimatorDataTableT UnPack() {
+    var _o = new AnimatorDataTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AnimatorDataTableT _o) {
+		byte[] key = { 0 };
+    _o.DataList = new List<SCHALE.Common.FlatData.AnimatorDataT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AnimatorDataTable> Pack(FlatBufferBuilder builder, AnimatorDataTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AnimatorDataTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.AnimatorData>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.AnimatorData.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAnimatorDataTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class AnimatorDataTableT
+{
+  public List<SCHALE.Common.FlatData.AnimatorDataT> DataList { get; set; }
+
+  public AnimatorDataTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/ArenaLevelSectionExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct ArenaLevelSectionExcel : IFlatbufferObject
@@ -46,6 +47,42 @@ public struct ArenaLevelSectionExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.ArenaLevelSectionExcel>(o);
   }
+  public ArenaLevelSectionExcelT UnPack() {
+    var _o = new ArenaLevelSectionExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(ArenaLevelSectionExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("ArenaLevelSection");
+    _o.ArenaSeasonId = TableEncryptionService.Convert(this.ArenaSeasonId, key);
+    _o.StartLevel = TableEncryptionService.Convert(this.StartLevel, key);
+    _o.LastLevel = TableEncryptionService.Convert(this.LastLevel, key);
+    _o.UserCount = TableEncryptionService.Convert(this.UserCount, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.ArenaLevelSectionExcel> Pack(FlatBufferBuilder builder, ArenaLevelSectionExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.ArenaLevelSectionExcel>);
+    return CreateArenaLevelSectionExcel(
+      builder,
+      _o.ArenaSeasonId,
+      _o.StartLevel,
+      _o.LastLevel,
+      _o.UserCount);
+  }
+}
+
+public class ArenaLevelSectionExcelT
+{
+  public long ArenaSeasonId { get; set; }
+  public long StartLevel { get; set; }
+  public long LastLevel { get; set; }
+  public long UserCount { get; set; }
+
+  public ArenaLevelSectionExcelT() {
+    this.ArenaSeasonId = 0;
+    this.StartLevel = 0;
+    this.LastLevel = 0;
+    this.UserCount = 0;
+  }
 }
 
 

SCHALE.Common/FlatData/ArenaLevelSectionExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct ArenaLevelSectionExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct ArenaLevelSectionExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.ArenaLevelSectionExcelTable>(o);
   }
+  public ArenaLevelSectionExcelTableT UnPack() {
+    var _o = new ArenaLevelSectionExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(ArenaLevelSectionExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("ArenaLevelSectionExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.ArenaLevelSectionExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.ArenaLevelSectionExcelTable> Pack(FlatBufferBuilder builder, ArenaLevelSectionExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.ArenaLevelSectionExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.ArenaLevelSectionExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.ArenaLevelSectionExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateArenaLevelSectionExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class ArenaLevelSectionExcelTableT
+{
+  public List<SCHALE.Common.FlatData.ArenaLevelSectionExcelT> DataList { get; set; }
+
+  public ArenaLevelSectionExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/ArenaMapExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct ArenaMapExcel : IFlatbufferObject
@@ -84,6 +85,65 @@ public struct ArenaMapExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.ArenaMapExcel>(o);
   }
+  public ArenaMapExcelT UnPack() {
+    var _o = new ArenaMapExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(ArenaMapExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("ArenaMap");
+    _o.UniqueId = TableEncryptionService.Convert(this.UniqueId, key);
+    _o.TerrainType = TableEncryptionService.Convert(this.TerrainType, key);
+    _o.TerrainTypeLocalizeKey = TableEncryptionService.Convert(this.TerrainTypeLocalizeKey, key);
+    _o.ImagePath = TableEncryptionService.Convert(this.ImagePath, key);
+    _o.GroundGroupId = TableEncryptionService.Convert(this.GroundGroupId, key);
+    _o.GroundGroupNameLocalizeKey = TableEncryptionService.Convert(this.GroundGroupNameLocalizeKey, key);
+    _o.StartRank = TableEncryptionService.Convert(this.StartRank, key);
+    _o.EndRank = TableEncryptionService.Convert(this.EndRank, key);
+    _o.GroundId = TableEncryptionService.Convert(this.GroundId, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.ArenaMapExcel> Pack(FlatBufferBuilder builder, ArenaMapExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.ArenaMapExcel>);
+    var _TerrainTypeLocalizeKey = _o.TerrainTypeLocalizeKey == null ? default(StringOffset) : builder.CreateString(_o.TerrainTypeLocalizeKey);
+    var _ImagePath = _o.ImagePath == null ? default(StringOffset) : builder.CreateString(_o.ImagePath);
+    var _GroundGroupNameLocalizeKey = _o.GroundGroupNameLocalizeKey == null ? default(StringOffset) : builder.CreateString(_o.GroundGroupNameLocalizeKey);
+    return CreateArenaMapExcel(
+      builder,
+      _o.UniqueId,
+      _o.TerrainType,
+      _TerrainTypeLocalizeKey,
+      _ImagePath,
+      _o.GroundGroupId,
+      _GroundGroupNameLocalizeKey,
+      _o.StartRank,
+      _o.EndRank,
+      _o.GroundId);
+  }
+}
+
+public class ArenaMapExcelT
+{
+  public long UniqueId { get; set; }
+  public long TerrainType { get; set; }
+  public string TerrainTypeLocalizeKey { get; set; }
+  public string ImagePath { get; set; }
+  public long GroundGroupId { get; set; }
+  public string GroundGroupNameLocalizeKey { get; set; }
+  public long StartRank { get; set; }
+  public long EndRank { get; set; }
+  public long GroundId { get; set; }
+
+  public ArenaMapExcelT() {
+    this.UniqueId = 0;
+    this.TerrainType = 0;
+    this.TerrainTypeLocalizeKey = null;
+    this.ImagePath = null;
+    this.GroundGroupId = 0;
+    this.GroundGroupNameLocalizeKey = null;
+    this.StartRank = 0;
+    this.EndRank = 0;
+    this.GroundId = 0;
+  }
 }
 
 

SCHALE.Common/FlatData/ArenaMapExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct ArenaMapExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct ArenaMapExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.ArenaMapExcelTable>(o);
   }
+  public ArenaMapExcelTableT UnPack() {
+    var _o = new ArenaMapExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(ArenaMapExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("ArenaMapExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.ArenaMapExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.ArenaMapExcelTable> Pack(FlatBufferBuilder builder, ArenaMapExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.ArenaMapExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.ArenaMapExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.ArenaMapExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateArenaMapExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class ArenaMapExcelTableT
+{
+  public List<SCHALE.Common.FlatData.ArenaMapExcelT> DataList { get; set; }
+
+  public ArenaMapExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/ArenaNPCExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct ArenaNPCExcel : IFlatbufferObject
@@ -122,6 +123,94 @@ public struct ArenaNPCExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.ArenaNPCExcel>(o);
   }
+  public ArenaNPCExcelT UnPack() {
+    var _o = new ArenaNPCExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(ArenaNPCExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("ArenaNPC");
+    _o.UniqueId = TableEncryptionService.Convert(this.UniqueId, key);
+    _o.Rank = TableEncryptionService.Convert(this.Rank, key);
+    _o.NPCAccountLevel = TableEncryptionService.Convert(this.NPCAccountLevel, key);
+    _o.NPCLevel = TableEncryptionService.Convert(this.NPCLevel, key);
+    _o.NPCLevelDeviation = TableEncryptionService.Convert(this.NPCLevelDeviation, key);
+    _o.NPCStarGrade = TableEncryptionService.Convert(this.NPCStarGrade, key);
+    _o.UseTSS = TableEncryptionService.Convert(this.UseTSS, key);
+    _o.ExceptionCharacterRarities = new List<SCHALE.Common.FlatData.Rarity>();
+    for (var _j = 0; _j < this.ExceptionCharacterRaritiesLength; ++_j) {_o.ExceptionCharacterRarities.Add(TableEncryptionService.Convert(this.ExceptionCharacterRarities(_j), key));}
+    _o.ExceptionMainCharacterIds = new List<long>();
+    for (var _j = 0; _j < this.ExceptionMainCharacterIdsLength; ++_j) {_o.ExceptionMainCharacterIds.Add(TableEncryptionService.Convert(this.ExceptionMainCharacterIds(_j), key));}
+    _o.ExceptionSupportCharacterIds = new List<long>();
+    for (var _j = 0; _j < this.ExceptionSupportCharacterIdsLength; ++_j) {_o.ExceptionSupportCharacterIds.Add(TableEncryptionService.Convert(this.ExceptionSupportCharacterIds(_j), key));}
+    _o.ExceptionTSSIds = new List<long>();
+    for (var _j = 0; _j < this.ExceptionTSSIdsLength; ++_j) {_o.ExceptionTSSIds.Add(TableEncryptionService.Convert(this.ExceptionTSSIds(_j), key));}
+  }
+  public static Offset<SCHALE.Common.FlatData.ArenaNPCExcel> Pack(FlatBufferBuilder builder, ArenaNPCExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.ArenaNPCExcel>);
+    var _ExceptionCharacterRarities = default(VectorOffset);
+    if (_o.ExceptionCharacterRarities != null) {
+      var __ExceptionCharacterRarities = _o.ExceptionCharacterRarities.ToArray();
+      _ExceptionCharacterRarities = CreateExceptionCharacterRaritiesVector(builder, __ExceptionCharacterRarities);
+    }
+    var _ExceptionMainCharacterIds = default(VectorOffset);
+    if (_o.ExceptionMainCharacterIds != null) {
+      var __ExceptionMainCharacterIds = _o.ExceptionMainCharacterIds.ToArray();
+      _ExceptionMainCharacterIds = CreateExceptionMainCharacterIdsVector(builder, __ExceptionMainCharacterIds);
+    }
+    var _ExceptionSupportCharacterIds = default(VectorOffset);
+    if (_o.ExceptionSupportCharacterIds != null) {
+      var __ExceptionSupportCharacterIds = _o.ExceptionSupportCharacterIds.ToArray();
+      _ExceptionSupportCharacterIds = CreateExceptionSupportCharacterIdsVector(builder, __ExceptionSupportCharacterIds);
+    }
+    var _ExceptionTSSIds = default(VectorOffset);
+    if (_o.ExceptionTSSIds != null) {
+      var __ExceptionTSSIds = _o.ExceptionTSSIds.ToArray();
+      _ExceptionTSSIds = CreateExceptionTSSIdsVector(builder, __ExceptionTSSIds);
+    }
+    return CreateArenaNPCExcel(
+      builder,
+      _o.UniqueId,
+      _o.Rank,
+      _o.NPCAccountLevel,
+      _o.NPCLevel,
+      _o.NPCLevelDeviation,
+      _o.NPCStarGrade,
+      _o.UseTSS,
+      _ExceptionCharacterRarities,
+      _ExceptionMainCharacterIds,
+      _ExceptionSupportCharacterIds,
+      _ExceptionTSSIds);
+  }
+}
+
+public class ArenaNPCExcelT
+{
+  public long UniqueId { get; set; }
+  public long Rank { get; set; }
+  public long NPCAccountLevel { get; set; }
+  public long NPCLevel { get; set; }
+  public long NPCLevelDeviation { get; set; }
+  public long NPCStarGrade { get; set; }
+  public bool UseTSS { get; set; }
+  public List<SCHALE.Common.FlatData.Rarity> ExceptionCharacterRarities { get; set; }
+  public List<long> ExceptionMainCharacterIds { get; set; }
+  public List<long> ExceptionSupportCharacterIds { get; set; }
+  public List<long> ExceptionTSSIds { get; set; }
+
+  public ArenaNPCExcelT() {
+    this.UniqueId = 0;
+    this.Rank = 0;
+    this.NPCAccountLevel = 0;
+    this.NPCLevel = 0;
+    this.NPCLevelDeviation = 0;
+    this.NPCStarGrade = 0;
+    this.UseTSS = false;
+    this.ExceptionCharacterRarities = null;
+    this.ExceptionMainCharacterIds = null;
+    this.ExceptionSupportCharacterIds = null;
+    this.ExceptionTSSIds = null;
+  }
 }
 
 

SCHALE.Common/FlatData/ArenaNPCExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct ArenaNPCExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct ArenaNPCExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.ArenaNPCExcelTable>(o);
   }
+  public ArenaNPCExcelTableT UnPack() {
+    var _o = new ArenaNPCExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(ArenaNPCExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("ArenaNPCExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.ArenaNPCExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.ArenaNPCExcelTable> Pack(FlatBufferBuilder builder, ArenaNPCExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.ArenaNPCExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.ArenaNPCExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.ArenaNPCExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateArenaNPCExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class ArenaNPCExcelTableT
+{
+  public List<SCHALE.Common.FlatData.ArenaNPCExcelT> DataList { get; set; }
+
+  public ArenaNPCExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/ArenaRewardExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct ArenaRewardExcel : IFlatbufferObject
@@ -114,6 +115,88 @@ public struct ArenaRewardExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.ArenaRewardExcel>(o);
   }
+  public ArenaRewardExcelT UnPack() {
+    var _o = new ArenaRewardExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(ArenaRewardExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("ArenaReward");
+    _o.UniqueId = TableEncryptionService.Convert(this.UniqueId, key);
+    _o.ArenaRewardType = TableEncryptionService.Convert(this.ArenaRewardType, key);
+    _o.RankStart = TableEncryptionService.Convert(this.RankStart, key);
+    _o.RankEnd = TableEncryptionService.Convert(this.RankEnd, key);
+    _o.RankIconPath = TableEncryptionService.Convert(this.RankIconPath, key);
+    _o.RewardParcelType = new List<SCHALE.Common.FlatData.ParcelType>();
+    for (var _j = 0; _j < this.RewardParcelTypeLength; ++_j) {_o.RewardParcelType.Add(TableEncryptionService.Convert(this.RewardParcelType(_j), key));}
+    _o.RewardParcelUniqueId = new List<long>();
+    for (var _j = 0; _j < this.RewardParcelUniqueIdLength; ++_j) {_o.RewardParcelUniqueId.Add(TableEncryptionService.Convert(this.RewardParcelUniqueId(_j), key));}
+    _o.RewardParcelUniqueName = new List<string>();
+    for (var _j = 0; _j < this.RewardParcelUniqueNameLength; ++_j) {_o.RewardParcelUniqueName.Add(TableEncryptionService.Convert(this.RewardParcelUniqueName(_j), key));}
+    _o.RewardParcelAmount = new List<long>();
+    for (var _j = 0; _j < this.RewardParcelAmountLength; ++_j) {_o.RewardParcelAmount.Add(TableEncryptionService.Convert(this.RewardParcelAmount(_j), key));}
+  }
+  public static Offset<SCHALE.Common.FlatData.ArenaRewardExcel> Pack(FlatBufferBuilder builder, ArenaRewardExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.ArenaRewardExcel>);
+    var _RankIconPath = _o.RankIconPath == null ? default(StringOffset) : builder.CreateString(_o.RankIconPath);
+    var _RewardParcelType = default(VectorOffset);
+    if (_o.RewardParcelType != null) {
+      var __RewardParcelType = _o.RewardParcelType.ToArray();
+      _RewardParcelType = CreateRewardParcelTypeVector(builder, __RewardParcelType);
+    }
+    var _RewardParcelUniqueId = default(VectorOffset);
+    if (_o.RewardParcelUniqueId != null) {
+      var __RewardParcelUniqueId = _o.RewardParcelUniqueId.ToArray();
+      _RewardParcelUniqueId = CreateRewardParcelUniqueIdVector(builder, __RewardParcelUniqueId);
+    }
+    var _RewardParcelUniqueName = default(VectorOffset);
+    if (_o.RewardParcelUniqueName != null) {
+      var __RewardParcelUniqueName = new StringOffset[_o.RewardParcelUniqueName.Count];
+      for (var _j = 0; _j < __RewardParcelUniqueName.Length; ++_j) { __RewardParcelUniqueName[_j] = builder.CreateString(_o.RewardParcelUniqueName[_j]); }
+      _RewardParcelUniqueName = CreateRewardParcelUniqueNameVector(builder, __RewardParcelUniqueName);
+    }
+    var _RewardParcelAmount = default(VectorOffset);
+    if (_o.RewardParcelAmount != null) {
+      var __RewardParcelAmount = _o.RewardParcelAmount.ToArray();
+      _RewardParcelAmount = CreateRewardParcelAmountVector(builder, __RewardParcelAmount);
+    }
+    return CreateArenaRewardExcel(
+      builder,
+      _o.UniqueId,
+      _o.ArenaRewardType,
+      _o.RankStart,
+      _o.RankEnd,
+      _RankIconPath,
+      _RewardParcelType,
+      _RewardParcelUniqueId,
+      _RewardParcelUniqueName,
+      _RewardParcelAmount);
+  }
+}
+
+public class ArenaRewardExcelT
+{
+  public long UniqueId { get; set; }
+  public SCHALE.Common.FlatData.ArenaRewardType ArenaRewardType { get; set; }
+  public long RankStart { get; set; }
+  public long RankEnd { get; set; }
+  public string RankIconPath { get; set; }
+  public List<SCHALE.Common.FlatData.ParcelType> RewardParcelType { get; set; }
+  public List<long> RewardParcelUniqueId { get; set; }
+  public List<string> RewardParcelUniqueName { get; set; }
+  public List<long> RewardParcelAmount { get; set; }
+
+  public ArenaRewardExcelT() {
+    this.UniqueId = 0;
+    this.ArenaRewardType = SCHALE.Common.FlatData.ArenaRewardType.None;
+    this.RankStart = 0;
+    this.RankEnd = 0;
+    this.RankIconPath = null;
+    this.RewardParcelType = null;
+    this.RewardParcelUniqueId = null;
+    this.RewardParcelUniqueName = null;
+    this.RewardParcelAmount = null;
+  }
 }
 
 

SCHALE.Common/FlatData/ArenaRewardExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct ArenaRewardExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct ArenaRewardExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.ArenaRewardExcelTable>(o);
   }
+  public ArenaRewardExcelTableT UnPack() {
+    var _o = new ArenaRewardExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(ArenaRewardExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("ArenaRewardExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.ArenaRewardExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.ArenaRewardExcelTable> Pack(FlatBufferBuilder builder, ArenaRewardExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.ArenaRewardExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.ArenaRewardExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.ArenaRewardExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateArenaRewardExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class ArenaRewardExcelTableT
+{
+  public List<SCHALE.Common.FlatData.ArenaRewardExcelT> DataList { get; set; }
+
+  public ArenaRewardExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/ArenaSeasonCloseRewardExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct ArenaSeasonCloseRewardExcel : IFlatbufferObject
@@ -100,6 +101,79 @@ public struct ArenaSeasonCloseRewardExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcel>(o);
   }
+  public ArenaSeasonCloseRewardExcelT UnPack() {
+    var _o = new ArenaSeasonCloseRewardExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(ArenaSeasonCloseRewardExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("ArenaSeasonCloseReward");
+    _o.SeasonId = TableEncryptionService.Convert(this.SeasonId, key);
+    _o.RankStart = TableEncryptionService.Convert(this.RankStart, key);
+    _o.RankEnd = TableEncryptionService.Convert(this.RankEnd, key);
+    _o.RewardParcelType = new List<SCHALE.Common.FlatData.ParcelType>();
+    for (var _j = 0; _j < this.RewardParcelTypeLength; ++_j) {_o.RewardParcelType.Add(TableEncryptionService.Convert(this.RewardParcelType(_j), key));}
+    _o.RewardParcelUniqueId = new List<long>();
+    for (var _j = 0; _j < this.RewardParcelUniqueIdLength; ++_j) {_o.RewardParcelUniqueId.Add(TableEncryptionService.Convert(this.RewardParcelUniqueId(_j), key));}
+    _o.RewardParcelUniqueName = new List<string>();
+    for (var _j = 0; _j < this.RewardParcelUniqueNameLength; ++_j) {_o.RewardParcelUniqueName.Add(TableEncryptionService.Convert(this.RewardParcelUniqueName(_j), key));}
+    _o.RewardParcelAmount = new List<long>();
+    for (var _j = 0; _j < this.RewardParcelAmountLength; ++_j) {_o.RewardParcelAmount.Add(TableEncryptionService.Convert(this.RewardParcelAmount(_j), key));}
+  }
+  public static Offset<SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcel> Pack(FlatBufferBuilder builder, ArenaSeasonCloseRewardExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcel>);
+    var _RewardParcelType = default(VectorOffset);
+    if (_o.RewardParcelType != null) {
+      var __RewardParcelType = _o.RewardParcelType.ToArray();
+      _RewardParcelType = CreateRewardParcelTypeVector(builder, __RewardParcelType);
+    }
+    var _RewardParcelUniqueId = default(VectorOffset);
+    if (_o.RewardParcelUniqueId != null) {
+      var __RewardParcelUniqueId = _o.RewardParcelUniqueId.ToArray();
+      _RewardParcelUniqueId = CreateRewardParcelUniqueIdVector(builder, __RewardParcelUniqueId);
+    }
+    var _RewardParcelUniqueName = default(VectorOffset);
+    if (_o.RewardParcelUniqueName != null) {
+      var __RewardParcelUniqueName = new StringOffset[_o.RewardParcelUniqueName.Count];
+      for (var _j = 0; _j < __RewardParcelUniqueName.Length; ++_j) { __RewardParcelUniqueName[_j] = builder.CreateString(_o.RewardParcelUniqueName[_j]); }
+      _RewardParcelUniqueName = CreateRewardParcelUniqueNameVector(builder, __RewardParcelUniqueName);
+    }
+    var _RewardParcelAmount = default(VectorOffset);
+    if (_o.RewardParcelAmount != null) {
+      var __RewardParcelAmount = _o.RewardParcelAmount.ToArray();
+      _RewardParcelAmount = CreateRewardParcelAmountVector(builder, __RewardParcelAmount);
+    }
+    return CreateArenaSeasonCloseRewardExcel(
+      builder,
+      _o.SeasonId,
+      _o.RankStart,
+      _o.RankEnd,
+      _RewardParcelType,
+      _RewardParcelUniqueId,
+      _RewardParcelUniqueName,
+      _RewardParcelAmount);
+  }
+}
+
+public class ArenaSeasonCloseRewardExcelT
+{
+  public long SeasonId { get; set; }
+  public long RankStart { get; set; }
+  public long RankEnd { get; set; }
+  public List<SCHALE.Common.FlatData.ParcelType> RewardParcelType { get; set; }
+  public List<long> RewardParcelUniqueId { get; set; }
+  public List<string> RewardParcelUniqueName { get; set; }
+  public List<long> RewardParcelAmount { get; set; }
+
+  public ArenaSeasonCloseRewardExcelT() {
+    this.SeasonId = 0;
+    this.RankStart = 0;
+    this.RankEnd = 0;
+    this.RewardParcelType = null;
+    this.RewardParcelUniqueId = null;
+    this.RewardParcelUniqueName = null;
+    this.RewardParcelAmount = null;
+  }
 }
 
 

SCHALE.Common/FlatData/ArenaSeasonCloseRewardExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct ArenaSeasonCloseRewardExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct ArenaSeasonCloseRewardExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcelTable>(o);
   }
+  public ArenaSeasonCloseRewardExcelTableT UnPack() {
+    var _o = new ArenaSeasonCloseRewardExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(ArenaSeasonCloseRewardExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("ArenaSeasonCloseRewardExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcelTable> Pack(FlatBufferBuilder builder, ArenaSeasonCloseRewardExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateArenaSeasonCloseRewardExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class ArenaSeasonCloseRewardExcelTableT
+{
+  public List<SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcelT> DataList { get; set; }
+
+  public ArenaSeasonCloseRewardExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/ArenaSeasonExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct ArenaSeasonExcel : IFlatbufferObject
@@ -62,6 +63,48 @@ public struct ArenaSeasonExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.ArenaSeasonExcel>(o);
   }
+  public ArenaSeasonExcelT UnPack() {
+    var _o = new ArenaSeasonExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(ArenaSeasonExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("ArenaSeason");
+    _o.UniqueId = TableEncryptionService.Convert(this.UniqueId, key);
+    _o.SeasonStartDate = TableEncryptionService.Convert(this.SeasonStartDate, key);
+    _o.SeasonEndDate = TableEncryptionService.Convert(this.SeasonEndDate, key);
+    _o.SeasonGroupLimit = TableEncryptionService.Convert(this.SeasonGroupLimit, key);
+    _o.PrevSeasonId = TableEncryptionService.Convert(this.PrevSeasonId, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.ArenaSeasonExcel> Pack(FlatBufferBuilder builder, ArenaSeasonExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.ArenaSeasonExcel>);
+    var _SeasonStartDate = _o.SeasonStartDate == null ? default(StringOffset) : builder.CreateString(_o.SeasonStartDate);
+    var _SeasonEndDate = _o.SeasonEndDate == null ? default(StringOffset) : builder.CreateString(_o.SeasonEndDate);
+    return CreateArenaSeasonExcel(
+      builder,
+      _o.UniqueId,
+      _SeasonStartDate,
+      _SeasonEndDate,
+      _o.SeasonGroupLimit,
+      _o.PrevSeasonId);
+  }
+}
+
+public class ArenaSeasonExcelT
+{
+  public long UniqueId { get; set; }
+  public string SeasonStartDate { get; set; }
+  public string SeasonEndDate { get; set; }
+  public long SeasonGroupLimit { get; set; }
+  public long PrevSeasonId { get; set; }
+
+  public ArenaSeasonExcelT() {
+    this.UniqueId = 0;
+    this.SeasonStartDate = null;
+    this.SeasonEndDate = null;
+    this.SeasonGroupLimit = 0;
+    this.PrevSeasonId = 0;
+  }
 }
 
 

SCHALE.Common/FlatData/ArenaSeasonExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct ArenaSeasonExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct ArenaSeasonExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.ArenaSeasonExcelTable>(o);
   }
+  public ArenaSeasonExcelTableT UnPack() {
+    var _o = new ArenaSeasonExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(ArenaSeasonExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("ArenaSeasonExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.ArenaSeasonExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.ArenaSeasonExcelTable> Pack(FlatBufferBuilder builder, ArenaSeasonExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.ArenaSeasonExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.ArenaSeasonExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.ArenaSeasonExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateArenaSeasonExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class ArenaSeasonExcelTableT
+{
+  public List<SCHALE.Common.FlatData.ArenaSeasonExcelT> DataList { get; set; }
+
+  public ArenaSeasonExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AttendanceExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AttendanceExcel : IFlatbufferObject
@@ -154,6 +155,110 @@ public struct AttendanceExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AttendanceExcel>(o);
   }
+  public AttendanceExcelT UnPack() {
+    var _o = new AttendanceExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AttendanceExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("Attendance");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.Type = TableEncryptionService.Convert(this.Type, key);
+    _o.CountdownPrefab = TableEncryptionService.Convert(this.CountdownPrefab, key);
+    _o.DisplayOrder = TableEncryptionService.Convert(this.DisplayOrder, key);
+    _o.AccountType = TableEncryptionService.Convert(this.AccountType, key);
+    _o.AccountLevelLimit = TableEncryptionService.Convert(this.AccountLevelLimit, key);
+    _o.Title = TableEncryptionService.Convert(this.Title, key);
+    _o.InfomationLocalizeCode = TableEncryptionService.Convert(this.InfomationLocalizeCode, key);
+    _o.CountRule = TableEncryptionService.Convert(this.CountRule, key);
+    _o.CountReset = TableEncryptionService.Convert(this.CountReset, key);
+    _o.BookSize = TableEncryptionService.Convert(this.BookSize, key);
+    _o.StartDate = TableEncryptionService.Convert(this.StartDate, key);
+    _o.StartableEndDate = TableEncryptionService.Convert(this.StartableEndDate, key);
+    _o.EndDate = TableEncryptionService.Convert(this.EndDate, key);
+    _o.ExpiryDate = TableEncryptionService.Convert(this.ExpiryDate, key);
+    _o.MailType = TableEncryptionService.Convert(this.MailType, key);
+    _o.DialogCategory = TableEncryptionService.Convert(this.DialogCategory, key);
+    _o.TitleImagePath = TableEncryptionService.Convert(this.TitleImagePath, key);
+    _o.DecorationImagePath = TableEncryptionService.Convert(this.DecorationImagePath, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.AttendanceExcel> Pack(FlatBufferBuilder builder, AttendanceExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AttendanceExcel>);
+    var _CountdownPrefab = _o.CountdownPrefab == null ? default(StringOffset) : builder.CreateString(_o.CountdownPrefab);
+    var _Title = _o.Title == null ? default(StringOffset) : builder.CreateString(_o.Title);
+    var _InfomationLocalizeCode = _o.InfomationLocalizeCode == null ? default(StringOffset) : builder.CreateString(_o.InfomationLocalizeCode);
+    var _StartDate = _o.StartDate == null ? default(StringOffset) : builder.CreateString(_o.StartDate);
+    var _StartableEndDate = _o.StartableEndDate == null ? default(StringOffset) : builder.CreateString(_o.StartableEndDate);
+    var _EndDate = _o.EndDate == null ? default(StringOffset) : builder.CreateString(_o.EndDate);
+    var _TitleImagePath = _o.TitleImagePath == null ? default(StringOffset) : builder.CreateString(_o.TitleImagePath);
+    var _DecorationImagePath = _o.DecorationImagePath == null ? default(StringOffset) : builder.CreateString(_o.DecorationImagePath);
+    return CreateAttendanceExcel(
+      builder,
+      _o.Id,
+      _o.Type,
+      _CountdownPrefab,
+      _o.DisplayOrder,
+      _o.AccountType,
+      _o.AccountLevelLimit,
+      _Title,
+      _InfomationLocalizeCode,
+      _o.CountRule,
+      _o.CountReset,
+      _o.BookSize,
+      _StartDate,
+      _StartableEndDate,
+      _EndDate,
+      _o.ExpiryDate,
+      _o.MailType,
+      _o.DialogCategory,
+      _TitleImagePath,
+      _DecorationImagePath);
+  }
+}
+
+public class AttendanceExcelT
+{
+  public long Id { get; set; }
+  public SCHALE.Common.FlatData.AttendanceType Type { get; set; }
+  public string CountdownPrefab { get; set; }
+  public long DisplayOrder { get; set; }
+  public SCHALE.Common.FlatData.AccountState AccountType { get; set; }
+  public long AccountLevelLimit { get; set; }
+  public string Title { get; set; }
+  public string InfomationLocalizeCode { get; set; }
+  public SCHALE.Common.FlatData.AttendanceCountRule CountRule { get; set; }
+  public SCHALE.Common.FlatData.AttendanceResetType CountReset { get; set; }
+  public long BookSize { get; set; }
+  public string StartDate { get; set; }
+  public string StartableEndDate { get; set; }
+  public string EndDate { get; set; }
+  public long ExpiryDate { get; set; }
+  public SCHALE.Common.FlatData.MailType MailType { get; set; }
+  public SCHALE.Common.FlatData.DialogCategory DialogCategory { get; set; }
+  public string TitleImagePath { get; set; }
+  public string DecorationImagePath { get; set; }
+
+  public AttendanceExcelT() {
+    this.Id = 0;
+    this.Type = SCHALE.Common.FlatData.AttendanceType.Basic;
+    this.CountdownPrefab = null;
+    this.DisplayOrder = 0;
+    this.AccountType = SCHALE.Common.FlatData.AccountState.WaitingSignIn;
+    this.AccountLevelLimit = 0;
+    this.Title = null;
+    this.InfomationLocalizeCode = null;
+    this.CountRule = SCHALE.Common.FlatData.AttendanceCountRule.Accumulation;
+    this.CountReset = SCHALE.Common.FlatData.AttendanceResetType.User;
+    this.BookSize = 0;
+    this.StartDate = null;
+    this.StartableEndDate = null;
+    this.EndDate = null;
+    this.ExpiryDate = 0;
+    this.MailType = SCHALE.Common.FlatData.MailType.System;
+    this.DialogCategory = SCHALE.Common.FlatData.DialogCategory.Cafe;
+    this.TitleImagePath = null;
+    this.DecorationImagePath = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AttendanceExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AttendanceExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct AttendanceExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AttendanceExcelTable>(o);
   }
+  public AttendanceExcelTableT UnPack() {
+    var _o = new AttendanceExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AttendanceExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AttendanceExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.AttendanceExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AttendanceExcelTable> Pack(FlatBufferBuilder builder, AttendanceExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AttendanceExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.AttendanceExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.AttendanceExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAttendanceExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class AttendanceExcelTableT
+{
+  public List<SCHALE.Common.FlatData.AttendanceExcelT> DataList { get; set; }
+
+  public AttendanceExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AttendanceRewardExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AttendanceRewardExcel : IFlatbufferObject
@@ -96,6 +97,69 @@ public struct AttendanceRewardExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AttendanceRewardExcel>(o);
   }
+  public AttendanceRewardExcelT UnPack() {
+    var _o = new AttendanceRewardExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AttendanceRewardExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AttendanceReward");
+    _o.AttendanceId = TableEncryptionService.Convert(this.AttendanceId, key);
+    _o.Day = TableEncryptionService.Convert(this.Day, key);
+    _o.RewardIcon = TableEncryptionService.Convert(this.RewardIcon, key);
+    _o.RewardParcelType = new List<SCHALE.Common.FlatData.ParcelType>();
+    for (var _j = 0; _j < this.RewardParcelTypeLength; ++_j) {_o.RewardParcelType.Add(TableEncryptionService.Convert(this.RewardParcelType(_j), key));}
+    _o.RewardId = new List<long>();
+    for (var _j = 0; _j < this.RewardIdLength; ++_j) {_o.RewardId.Add(TableEncryptionService.Convert(this.RewardId(_j), key));}
+    _o.RewardAmount = new List<long>();
+    for (var _j = 0; _j < this.RewardAmountLength; ++_j) {_o.RewardAmount.Add(TableEncryptionService.Convert(this.RewardAmount(_j), key));}
+  }
+  public static Offset<SCHALE.Common.FlatData.AttendanceRewardExcel> Pack(FlatBufferBuilder builder, AttendanceRewardExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AttendanceRewardExcel>);
+    var _RewardIcon = _o.RewardIcon == null ? default(StringOffset) : builder.CreateString(_o.RewardIcon);
+    var _RewardParcelType = default(VectorOffset);
+    if (_o.RewardParcelType != null) {
+      var __RewardParcelType = _o.RewardParcelType.ToArray();
+      _RewardParcelType = CreateRewardParcelTypeVector(builder, __RewardParcelType);
+    }
+    var _RewardId = default(VectorOffset);
+    if (_o.RewardId != null) {
+      var __RewardId = _o.RewardId.ToArray();
+      _RewardId = CreateRewardIdVector(builder, __RewardId);
+    }
+    var _RewardAmount = default(VectorOffset);
+    if (_o.RewardAmount != null) {
+      var __RewardAmount = _o.RewardAmount.ToArray();
+      _RewardAmount = CreateRewardAmountVector(builder, __RewardAmount);
+    }
+    return CreateAttendanceRewardExcel(
+      builder,
+      _o.AttendanceId,
+      _o.Day,
+      _RewardIcon,
+      _RewardParcelType,
+      _RewardId,
+      _RewardAmount);
+  }
+}
+
+public class AttendanceRewardExcelT
+{
+  public long AttendanceId { get; set; }
+  public long Day { get; set; }
+  public string RewardIcon { get; set; }
+  public List<SCHALE.Common.FlatData.ParcelType> RewardParcelType { get; set; }
+  public List<long> RewardId { get; set; }
+  public List<long> RewardAmount { get; set; }
+
+  public AttendanceRewardExcelT() {
+    this.AttendanceId = 0;
+    this.Day = 0;
+    this.RewardIcon = null;
+    this.RewardParcelType = null;
+    this.RewardId = null;
+    this.RewardAmount = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AttendanceRewardExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AttendanceRewardExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct AttendanceRewardExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AttendanceRewardExcelTable>(o);
   }
+  public AttendanceRewardExcelTableT UnPack() {
+    var _o = new AttendanceRewardExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AttendanceRewardExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AttendanceRewardExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.AttendanceRewardExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.AttendanceRewardExcelTable> Pack(FlatBufferBuilder builder, AttendanceRewardExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AttendanceRewardExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.AttendanceRewardExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.AttendanceRewardExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateAttendanceRewardExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class AttendanceRewardExcelTableT
+{
+  public List<SCHALE.Common.FlatData.AttendanceRewardExcelT> DataList { get; set; }
+
+  public AttendanceRewardExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/AudioAnimatorExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct AudioAnimatorExcel : IFlatbufferObject
@@ -112,6 +113,93 @@ public struct AudioAnimatorExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AudioAnimatorExcel>(o);
   }
+  public AudioAnimatorExcelT UnPack() {
+    var _o = new AudioAnimatorExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(AudioAnimatorExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("AudioAnimator");
+    _o.ControllerNameHash = TableEncryptionService.Convert(this.ControllerNameHash, key);
+    _o.VoiceNamePrefix = TableEncryptionService.Convert(this.VoiceNamePrefix, key);
+    _o.StateNameHash = TableEncryptionService.Convert(this.StateNameHash, key);
+    _o.StateName = TableEncryptionService.Convert(this.StateName, key);
+    _o.IgnoreInterruptDelay = TableEncryptionService.Convert(this.IgnoreInterruptDelay, key);
+    _o.IgnoreInterruptPlay = TableEncryptionService.Convert(this.IgnoreInterruptPlay, key);
+    _o.Volume = TableEncryptionService.Convert(this.Volume, key);
+    _o.Delay = TableEncryptionService.Convert(this.Delay, key);
+    _o.RandomPitchMin = TableEncryptionService.Convert(this.RandomPitchMin, key);
+    _o.RandomPitchMax = TableEncryptionService.Convert(this.RandomPitchMax, key);
+    _o.AudioPriority = TableEncryptionService.Convert(this.AudioPriority, key);
+    _o.AudioClipPath = new List<string>();
+    for (var _j = 0; _j < this.AudioClipPathLength; ++_j) {_o.AudioClipPath.Add(TableEncryptionService.Convert(this.AudioClipPath(_j), key));}
+    _o.VoiceHash = new List<uint>();
+    for (var _j = 0; _j < this.VoiceHashLength; ++_j) {_o.VoiceHash.Add(TableEncryptionService.Convert(this.VoiceHash(_j), key));}
+  }
+  public static Offset<SCHALE.Common.FlatData.AudioAnimatorExcel> Pack(FlatBufferBuilder builder, AudioAnimatorExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.AudioAnimatorExcel>);
+    var _VoiceNamePrefix = _o.VoiceNamePrefix == null ? default(StringOffset) : builder.CreateString(_o.VoiceNamePrefix);
+    var _StateName = _o.StateName == null ? default(StringOffset) : builder.CreateString(_o.StateName);
+    var _AudioClipPath = default(VectorOffset);
+    if (_o.AudioClipPath != null) {
+      var __AudioClipPath = new StringOffset[_o.AudioClipPath.Count];
+      for (var _j = 0; _j < __AudioClipPath.Length; ++_j) { __AudioClipPath[_j] = builder.CreateString(_o.AudioClipPath[_j]); }
+      _AudioClipPath = CreateAudioClipPathVector(builder, __AudioClipPath);
+    }
+    var _VoiceHash = default(VectorOffset);
+    if (_o.VoiceHash != null) {
+      var __VoiceHash = _o.VoiceHash.ToArray();
+      _VoiceHash = CreateVoiceHashVector(builder, __VoiceHash);
+    }
+    return CreateAudioAnimatorExcel(
+      builder,
+      _o.ControllerNameHash,
+      _VoiceNamePrefix,
+      _o.StateNameHash,
+      _StateName,
+      _o.IgnoreInterruptDelay,
+      _o.IgnoreInterruptPlay,
+      _o.Volume,
+      _o.Delay,
+      _o.RandomPitchMin,
+      _o.RandomPitchMax,
+      _o.AudioPriority,
+      _AudioClipPath,
+      _VoiceHash);
+  }
+}
+
+public class AudioAnimatorExcelT
+{
+  public uint ControllerNameHash { get; set; }
+  public string VoiceNamePrefix { get; set; }
+  public uint StateNameHash { get; set; }
+  public string StateName { get; set; }
+  public bool IgnoreInterruptDelay { get; set; }
+  public bool IgnoreInterruptPlay { get; set; }
+  public float Volume { get; set; }
+  public float Delay { get; set; }
+  public int RandomPitchMin { get; set; }
+  public int RandomPitchMax { get; set; }
+  public int AudioPriority { get; set; }
+  public List<string> AudioClipPath { get; set; }
+  public List<uint> VoiceHash { get; set; }
+
+  public AudioAnimatorExcelT() {
+    this.ControllerNameHash = 0;
+    this.VoiceNamePrefix = null;
+    this.StateNameHash = 0;
+    this.StateName = null;
+    this.IgnoreInterruptDelay = false;
+    this.IgnoreInterruptPlay = false;
+    this.Volume = 0.0f;
+    this.Delay = 0.0f;
+    this.RandomPitchMin = 0;
+    this.RandomPitchMax = 0;
+    this.AudioPriority = 0;
+    this.AudioClipPath = null;
+    this.VoiceHash = null;
+  }
 }
 
 

SCHALE.Common/FlatData/BGMExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct BGMExcel : IFlatbufferObject
@@ -140,6 +141,101 @@ public struct BGMExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.BGMExcel>(o);
   }
+  public BGMExcelT UnPack() {
+    var _o = new BGMExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(BGMExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("BGM");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.Nation_ = new List<SCHALE.Common.FlatData.Nation>();
+    for (var _j = 0; _j < this.Nation_Length; ++_j) {_o.Nation_.Add(TableEncryptionService.Convert(this.Nation_(_j), key));}
+    _o.Path = new List<string>();
+    for (var _j = 0; _j < this.PathLength; ++_j) {_o.Path.Add(TableEncryptionService.Convert(this.Path(_j), key));}
+    _o.Volume = new List<float>();
+    for (var _j = 0; _j < this.VolumeLength; ++_j) {_o.Volume.Add(TableEncryptionService.Convert(this.Volume(_j), key));}
+    _o.LoopStartTime = new List<float>();
+    for (var _j = 0; _j < this.LoopStartTimeLength; ++_j) {_o.LoopStartTime.Add(TableEncryptionService.Convert(this.LoopStartTime(_j), key));}
+    _o.LoopEndTime = new List<float>();
+    for (var _j = 0; _j < this.LoopEndTimeLength; ++_j) {_o.LoopEndTime.Add(TableEncryptionService.Convert(this.LoopEndTime(_j), key));}
+    _o.LoopTranstionTime = new List<float>();
+    for (var _j = 0; _j < this.LoopTranstionTimeLength; ++_j) {_o.LoopTranstionTime.Add(TableEncryptionService.Convert(this.LoopTranstionTime(_j), key));}
+    _o.LoopOffsetTime = new List<float>();
+    for (var _j = 0; _j < this.LoopOffsetTimeLength; ++_j) {_o.LoopOffsetTime.Add(TableEncryptionService.Convert(this.LoopOffsetTime(_j), key));}
+  }
+  public static Offset<SCHALE.Common.FlatData.BGMExcel> Pack(FlatBufferBuilder builder, BGMExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.BGMExcel>);
+    var _Nation_ = default(VectorOffset);
+    if (_o.Nation_ != null) {
+      var __Nation_ = _o.Nation_.ToArray();
+      _Nation_ = CreateNation_Vector(builder, __Nation_);
+    }
+    var _Path = default(VectorOffset);
+    if (_o.Path != null) {
+      var __Path = new StringOffset[_o.Path.Count];
+      for (var _j = 0; _j < __Path.Length; ++_j) { __Path[_j] = builder.CreateString(_o.Path[_j]); }
+      _Path = CreatePathVector(builder, __Path);
+    }
+    var _Volume = default(VectorOffset);
+    if (_o.Volume != null) {
+      var __Volume = _o.Volume.ToArray();
+      _Volume = CreateVolumeVector(builder, __Volume);
+    }
+    var _LoopStartTime = default(VectorOffset);
+    if (_o.LoopStartTime != null) {
+      var __LoopStartTime = _o.LoopStartTime.ToArray();
+      _LoopStartTime = CreateLoopStartTimeVector(builder, __LoopStartTime);
+    }
+    var _LoopEndTime = default(VectorOffset);
+    if (_o.LoopEndTime != null) {
+      var __LoopEndTime = _o.LoopEndTime.ToArray();
+      _LoopEndTime = CreateLoopEndTimeVector(builder, __LoopEndTime);
+    }
+    var _LoopTranstionTime = default(VectorOffset);
+    if (_o.LoopTranstionTime != null) {
+      var __LoopTranstionTime = _o.LoopTranstionTime.ToArray();
+      _LoopTranstionTime = CreateLoopTranstionTimeVector(builder, __LoopTranstionTime);
+    }
+    var _LoopOffsetTime = default(VectorOffset);
+    if (_o.LoopOffsetTime != null) {
+      var __LoopOffsetTime = _o.LoopOffsetTime.ToArray();
+      _LoopOffsetTime = CreateLoopOffsetTimeVector(builder, __LoopOffsetTime);
+    }
+    return CreateBGMExcel(
+      builder,
+      _o.Id,
+      _Nation_,
+      _Path,
+      _Volume,
+      _LoopStartTime,
+      _LoopEndTime,
+      _LoopTranstionTime,
+      _LoopOffsetTime);
+  }
+}
+
+public class BGMExcelT
+{
+  public long Id { get; set; }
+  public List<SCHALE.Common.FlatData.Nation> Nation_ { get; set; }
+  public List<string> Path { get; set; }
+  public List<float> Volume { get; set; }
+  public List<float> LoopStartTime { get; set; }
+  public List<float> LoopEndTime { get; set; }
+  public List<float> LoopTranstionTime { get; set; }
+  public List<float> LoopOffsetTime { get; set; }
+
+  public BGMExcelT() {
+    this.Id = 0;
+    this.Nation_ = null;
+    this.Path = null;
+    this.Volume = null;
+    this.LoopStartTime = null;
+    this.LoopEndTime = null;
+    this.LoopTranstionTime = null;
+    this.LoopOffsetTime = null;
+  }
 }
 
 

SCHALE.Common/FlatData/BGMRaidExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct BGMRaidExcel : IFlatbufferObject
@@ -42,6 +43,38 @@ public struct BGMRaidExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.BGMRaidExcel>(o);
   }
+  public BGMRaidExcelT UnPack() {
+    var _o = new BGMRaidExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(BGMRaidExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("BGMRaid");
+    _o.StageId = TableEncryptionService.Convert(this.StageId, key);
+    _o.PhaseIndex = TableEncryptionService.Convert(this.PhaseIndex, key);
+    _o.BGMId = TableEncryptionService.Convert(this.BGMId, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.BGMRaidExcel> Pack(FlatBufferBuilder builder, BGMRaidExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.BGMRaidExcel>);
+    return CreateBGMRaidExcel(
+      builder,
+      _o.StageId,
+      _o.PhaseIndex,
+      _o.BGMId);
+  }
+}
+
+public class BGMRaidExcelT
+{
+  public long StageId { get; set; }
+  public long PhaseIndex { get; set; }
+  public long BGMId { get; set; }
+
+  public BGMRaidExcelT() {
+    this.StageId = 0;
+    this.PhaseIndex = 0;
+    this.BGMId = 0;
+  }
 }
 
 

SCHALE.Common/FlatData/BGMUIExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct BGMUIExcel : IFlatbufferObject
@@ -50,6 +51,46 @@ public struct BGMUIExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.BGMUIExcel>(o);
   }
+  public BGMUIExcelT UnPack() {
+    var _o = new BGMUIExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(BGMUIExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("BGMUI");
+    _o.UIPrefab = TableEncryptionService.Convert(this.UIPrefab, key);
+    _o.BGMId = TableEncryptionService.Convert(this.BGMId, key);
+    _o.BGMId2nd = TableEncryptionService.Convert(this.BGMId2nd, key);
+    _o.BGMId3rd = TableEncryptionService.Convert(this.BGMId3rd, key);
+    _o.EventContentId = TableEncryptionService.Convert(this.EventContentId, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.BGMUIExcel> Pack(FlatBufferBuilder builder, BGMUIExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.BGMUIExcel>);
+    return CreateBGMUIExcel(
+      builder,
+      _o.UIPrefab,
+      _o.BGMId,
+      _o.BGMId2nd,
+      _o.BGMId3rd,
+      _o.EventContentId);
+  }
+}
+
+public class BGMUIExcelT
+{
+  public uint UIPrefab { get; set; }
+  public long BGMId { get; set; }
+  public long BGMId2nd { get; set; }
+  public long BGMId3rd { get; set; }
+  public long EventContentId { get; set; }
+
+  public BGMUIExcelT() {
+    this.UIPrefab = 0;
+    this.BGMId = 0;
+    this.BGMId2nd = 0;
+    this.BGMId3rd = 0;
+    this.EventContentId = 0;
+  }
 }
 
 

SCHALE.Common/FlatData/BattleLevelFactorExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct BattleLevelFactorExcel : IFlatbufferObject
@@ -38,6 +39,34 @@ public struct BattleLevelFactorExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.BattleLevelFactorExcel>(o);
   }
+  public BattleLevelFactorExcelT UnPack() {
+    var _o = new BattleLevelFactorExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(BattleLevelFactorExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("BattleLevelFactor");
+    _o.LevelDiff = TableEncryptionService.Convert(this.LevelDiff, key);
+    _o.DamageRate = TableEncryptionService.Convert(this.DamageRate, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.BattleLevelFactorExcel> Pack(FlatBufferBuilder builder, BattleLevelFactorExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.BattleLevelFactorExcel>);
+    return CreateBattleLevelFactorExcel(
+      builder,
+      _o.LevelDiff,
+      _o.DamageRate);
+  }
+}
+
+public class BattleLevelFactorExcelT
+{
+  public int LevelDiff { get; set; }
+  public long DamageRate { get; set; }
+
+  public BattleLevelFactorExcelT() {
+    this.LevelDiff = 0;
+    this.DamageRate = 0;
+  }
 }
 
 

SCHALE.Common/FlatData/BattleLevelFactorExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct BattleLevelFactorExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct BattleLevelFactorExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.BattleLevelFactorExcelTable>(o);
   }
+  public BattleLevelFactorExcelTableT UnPack() {
+    var _o = new BattleLevelFactorExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(BattleLevelFactorExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("BattleLevelFactorExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.BattleLevelFactorExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.BattleLevelFactorExcelTable> Pack(FlatBufferBuilder builder, BattleLevelFactorExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.BattleLevelFactorExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.BattleLevelFactorExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.BattleLevelFactorExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateBattleLevelFactorExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class BattleLevelFactorExcelTableT
+{
+  public List<SCHALE.Common.FlatData.BattleLevelFactorExcelT> DataList { get; set; }
+
+  public BattleLevelFactorExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/BlendData.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct BlendData : IFlatbufferObject
@@ -44,6 +45,41 @@ public struct BlendData : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.BlendData>(o);
   }
+  public BlendDataT UnPack() {
+    var _o = new BlendDataT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(BlendDataT _o) {
+		byte[] key = { 0 };
+    _o.Type = TableEncryptionService.Convert(this.Type, key);
+    _o.InfoList = new List<SCHALE.Common.FlatData.BlendInfoT>();
+    for (var _j = 0; _j < this.InfoListLength; ++_j) {_o.InfoList.Add(this.InfoList(_j).HasValue ? this.InfoList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.BlendData> Pack(FlatBufferBuilder builder, BlendDataT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.BlendData>);
+    var _InfoList = default(VectorOffset);
+    if (_o.InfoList != null) {
+      var __InfoList = new Offset<SCHALE.Common.FlatData.BlendInfo>[_o.InfoList.Count];
+      for (var _j = 0; _j < __InfoList.Length; ++_j) { __InfoList[_j] = SCHALE.Common.FlatData.BlendInfo.Pack(builder, _o.InfoList[_j]); }
+      _InfoList = CreateInfoListVector(builder, __InfoList);
+    }
+    return CreateBlendData(
+      builder,
+      _o.Type,
+      _InfoList);
+  }
+}
+
+public class BlendDataT
+{
+  public int Type { get; set; }
+  public List<SCHALE.Common.FlatData.BlendInfoT> InfoList { get; set; }
+
+  public BlendDataT() {
+    this.Type = 0;
+    this.InfoList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/BlendInfo.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct BlendInfo : IFlatbufferObject
@@ -42,6 +43,38 @@ public struct BlendInfo : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.BlendInfo>(o);
   }
+  public BlendInfoT UnPack() {
+    var _o = new BlendInfoT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(BlendInfoT _o) {
+		byte[] key = { 0 };
+    _o.From = TableEncryptionService.Convert(this.From, key);
+    _o.To = TableEncryptionService.Convert(this.To, key);
+    _o.Blend = TableEncryptionService.Convert(this.Blend, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.BlendInfo> Pack(FlatBufferBuilder builder, BlendInfoT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.BlendInfo>);
+    return CreateBlendInfo(
+      builder,
+      _o.From,
+      _o.To,
+      _o.Blend);
+  }
+}
+
+public class BlendInfoT
+{
+  public int From { get; set; }
+  public int To { get; set; }
+  public float Blend { get; set; }
+
+  public BlendInfoT() {
+    this.From = 0;
+    this.To = 0;
+    this.Blend = 0.0f;
+  }
 }
 
 

SCHALE.Common/FlatData/BossExternalBTExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct BossExternalBTExcel : IFlatbufferObject
@@ -74,6 +75,60 @@ public struct BossExternalBTExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.BossExternalBTExcel>(o);
   }
+  public BossExternalBTExcelT UnPack() {
+    var _o = new BossExternalBTExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(BossExternalBTExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("BossExternalBT");
+    _o.ExternalBTId = TableEncryptionService.Convert(this.ExternalBTId, key);
+    _o.AIPhase = TableEncryptionService.Convert(this.AIPhase, key);
+    _o.ExternalBTNodeType = TableEncryptionService.Convert(this.ExternalBTNodeType, key);
+    _o.ExternalBTTrigger = TableEncryptionService.Convert(this.ExternalBTTrigger, key);
+    _o.TriggerArgument = TableEncryptionService.Convert(this.TriggerArgument, key);
+    _o.BehaviorRate = TableEncryptionService.Convert(this.BehaviorRate, key);
+    _o.ExternalBehavior = TableEncryptionService.Convert(this.ExternalBehavior, key);
+    _o.BehaviorArgument = TableEncryptionService.Convert(this.BehaviorArgument, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.BossExternalBTExcel> Pack(FlatBufferBuilder builder, BossExternalBTExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.BossExternalBTExcel>);
+    var _TriggerArgument = _o.TriggerArgument == null ? default(StringOffset) : builder.CreateString(_o.TriggerArgument);
+    var _BehaviorArgument = _o.BehaviorArgument == null ? default(StringOffset) : builder.CreateString(_o.BehaviorArgument);
+    return CreateBossExternalBTExcel(
+      builder,
+      _o.ExternalBTId,
+      _o.AIPhase,
+      _o.ExternalBTNodeType,
+      _o.ExternalBTTrigger,
+      _TriggerArgument,
+      _o.BehaviorRate,
+      _o.ExternalBehavior,
+      _BehaviorArgument);
+  }
+}
+
+public class BossExternalBTExcelT
+{
+  public long ExternalBTId { get; set; }
+  public long AIPhase { get; set; }
+  public SCHALE.Common.FlatData.ExternalBTNodeType ExternalBTNodeType { get; set; }
+  public SCHALE.Common.FlatData.ExternalBTTrigger ExternalBTTrigger { get; set; }
+  public string TriggerArgument { get; set; }
+  public long BehaviorRate { get; set; }
+  public SCHALE.Common.FlatData.ExternalBehavior ExternalBehavior { get; set; }
+  public string BehaviorArgument { get; set; }
+
+  public BossExternalBTExcelT() {
+    this.ExternalBTId = 0;
+    this.AIPhase = 0;
+    this.ExternalBTNodeType = SCHALE.Common.FlatData.ExternalBTNodeType.Sequence;
+    this.ExternalBTTrigger = SCHALE.Common.FlatData.ExternalBTTrigger.None;
+    this.TriggerArgument = null;
+    this.BehaviorRate = 0;
+    this.ExternalBehavior = SCHALE.Common.FlatData.ExternalBehavior.UseNextExSkill;
+    this.BehaviorArgument = null;
+  }
 }
 
 

SCHALE.Common/FlatData/BossExternalBTExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct BossExternalBTExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct BossExternalBTExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.BossExternalBTExcelTable>(o);
   }
+  public BossExternalBTExcelTableT UnPack() {
+    var _o = new BossExternalBTExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(BossExternalBTExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("BossExternalBTExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.BossExternalBTExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.BossExternalBTExcelTable> Pack(FlatBufferBuilder builder, BossExternalBTExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.BossExternalBTExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.BossExternalBTExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.BossExternalBTExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateBossExternalBTExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class BossExternalBTExcelTableT
+{
+  public List<SCHALE.Common.FlatData.BossExternalBTExcelT> DataList { get; set; }
+
+  public BossExternalBTExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/BossPhaseExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct BossPhaseExcel : IFlatbufferObject
@@ -64,6 +65,49 @@ public struct BossPhaseExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.BossPhaseExcel>(o);
   }
+  public BossPhaseExcelT UnPack() {
+    var _o = new BossPhaseExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(BossPhaseExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("BossPhase");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.AIPhase = TableEncryptionService.Convert(this.AIPhase, key);
+    _o.NormalAttackSkillUniqueName = TableEncryptionService.Convert(this.NormalAttackSkillUniqueName, key);
+    _o.UseExSkill = new List<bool>();
+    for (var _j = 0; _j < this.UseExSkillLength; ++_j) {_o.UseExSkill.Add(TableEncryptionService.Convert(this.UseExSkill(_j), key));}
+  }
+  public static Offset<SCHALE.Common.FlatData.BossPhaseExcel> Pack(FlatBufferBuilder builder, BossPhaseExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.BossPhaseExcel>);
+    var _NormalAttackSkillUniqueName = _o.NormalAttackSkillUniqueName == null ? default(StringOffset) : builder.CreateString(_o.NormalAttackSkillUniqueName);
+    var _UseExSkill = default(VectorOffset);
+    if (_o.UseExSkill != null) {
+      var __UseExSkill = _o.UseExSkill.ToArray();
+      _UseExSkill = CreateUseExSkillVector(builder, __UseExSkill);
+    }
+    return CreateBossPhaseExcel(
+      builder,
+      _o.Id,
+      _o.AIPhase,
+      _NormalAttackSkillUniqueName,
+      _UseExSkill);
+  }
+}
+
+public class BossPhaseExcelT
+{
+  public long Id { get; set; }
+  public long AIPhase { get; set; }
+  public string NormalAttackSkillUniqueName { get; set; }
+  public List<bool> UseExSkill { get; set; }
+
+  public BossPhaseExcelT() {
+    this.Id = 0;
+    this.AIPhase = 0;
+    this.NormalAttackSkillUniqueName = null;
+    this.UseExSkill = null;
+  }
 }
 
 

SCHALE.Common/FlatData/BossPhaseExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct BossPhaseExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct BossPhaseExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.BossPhaseExcelTable>(o);
   }
+  public BossPhaseExcelTableT UnPack() {
+    var _o = new BossPhaseExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(BossPhaseExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("BossPhaseExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.BossPhaseExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.BossPhaseExcelTable> Pack(FlatBufferBuilder builder, BossPhaseExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.BossPhaseExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.BossPhaseExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.BossPhaseExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateBossPhaseExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class BossPhaseExcelTableT
+{
+  public List<SCHALE.Common.FlatData.BossPhaseExcelT> DataList { get; set; }
+
+  public BossPhaseExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/BuffParticleExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct BuffParticleExcel : IFlatbufferObject
@@ -74,6 +75,50 @@ public struct BuffParticleExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.BuffParticleExcel>(o);
   }
+  public BuffParticleExcelT UnPack() {
+    var _o = new BuffParticleExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(BuffParticleExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("BuffParticle");
+    _o.UniqueId = TableEncryptionService.Convert(this.UniqueId, key);
+    _o.UniqueName = TableEncryptionService.Convert(this.UniqueName, key);
+    _o.BuffType = TableEncryptionService.Convert(this.BuffType, key);
+    _o.BuffName = TableEncryptionService.Convert(this.BuffName, key);
+    _o.ResourcePath = TableEncryptionService.Convert(this.ResourcePath, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.BuffParticleExcel> Pack(FlatBufferBuilder builder, BuffParticleExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.BuffParticleExcel>);
+    var _UniqueName = _o.UniqueName == null ? default(StringOffset) : builder.CreateString(_o.UniqueName);
+    var _BuffType = _o.BuffType == null ? default(StringOffset) : builder.CreateString(_o.BuffType);
+    var _BuffName = _o.BuffName == null ? default(StringOffset) : builder.CreateString(_o.BuffName);
+    var _ResourcePath = _o.ResourcePath == null ? default(StringOffset) : builder.CreateString(_o.ResourcePath);
+    return CreateBuffParticleExcel(
+      builder,
+      _o.UniqueId,
+      _UniqueName,
+      _BuffType,
+      _BuffName,
+      _ResourcePath);
+  }
+}
+
+public class BuffParticleExcelT
+{
+  public long UniqueId { get; set; }
+  public string UniqueName { get; set; }
+  public string BuffType { get; set; }
+  public string BuffName { get; set; }
+  public string ResourcePath { get; set; }
+
+  public BuffParticleExcelT() {
+    this.UniqueId = 0;
+    this.UniqueName = null;
+    this.BuffType = null;
+    this.BuffName = null;
+    this.ResourcePath = null;
+  }
 }
 
 

SCHALE.Common/FlatData/BuffParticleExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct BuffParticleExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct BuffParticleExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.BuffParticleExcelTable>(o);
   }
+  public BuffParticleExcelTableT UnPack() {
+    var _o = new BuffParticleExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(BuffParticleExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("BuffParticleExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.BuffParticleExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.BuffParticleExcelTable> Pack(FlatBufferBuilder builder, BuffParticleExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.BuffParticleExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.BuffParticleExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.BuffParticleExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateBuffParticleExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class BuffParticleExcelTableT
+{
+  public List<SCHALE.Common.FlatData.BuffParticleExcelT> DataList { get; set; }
+
+  public BuffParticleExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/BulletArmorDamageFactorExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct BulletArmorDamageFactorExcel : IFlatbufferObject
@@ -68,6 +69,59 @@ public struct BulletArmorDamageFactorExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.BulletArmorDamageFactorExcel>(o);
   }
+  public BulletArmorDamageFactorExcelT UnPack() {
+    var _o = new BulletArmorDamageFactorExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(BulletArmorDamageFactorExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("BulletArmorDamageFactor");
+    _o.DamageFactorGroupId = TableEncryptionService.Convert(this.DamageFactorGroupId, key);
+    _o.BulletType = TableEncryptionService.Convert(this.BulletType, key);
+    _o.ArmorType = TableEncryptionService.Convert(this.ArmorType, key);
+    _o.DamageRate = TableEncryptionService.Convert(this.DamageRate, key);
+    _o.DamageAttribute = TableEncryptionService.Convert(this.DamageAttribute, key);
+    _o.MinDamageRate = TableEncryptionService.Convert(this.MinDamageRate, key);
+    _o.MaxDamageRate = TableEncryptionService.Convert(this.MaxDamageRate, key);
+    _o.ShowHighlightFloater = TableEncryptionService.Convert(this.ShowHighlightFloater, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.BulletArmorDamageFactorExcel> Pack(FlatBufferBuilder builder, BulletArmorDamageFactorExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.BulletArmorDamageFactorExcel>);
+    var _DamageFactorGroupId = _o.DamageFactorGroupId == null ? default(StringOffset) : builder.CreateString(_o.DamageFactorGroupId);
+    return CreateBulletArmorDamageFactorExcel(
+      builder,
+      _DamageFactorGroupId,
+      _o.BulletType,
+      _o.ArmorType,
+      _o.DamageRate,
+      _o.DamageAttribute,
+      _o.MinDamageRate,
+      _o.MaxDamageRate,
+      _o.ShowHighlightFloater);
+  }
+}
+
+public class BulletArmorDamageFactorExcelT
+{
+  public string DamageFactorGroupId { get; set; }
+  public SCHALE.Common.FlatData.BulletType BulletType { get; set; }
+  public SCHALE.Common.FlatData.ArmorType ArmorType { get; set; }
+  public long DamageRate { get; set; }
+  public SCHALE.Common.FlatData.DamageAttribute DamageAttribute { get; set; }
+  public long MinDamageRate { get; set; }
+  public long MaxDamageRate { get; set; }
+  public bool ShowHighlightFloater { get; set; }
+
+  public BulletArmorDamageFactorExcelT() {
+    this.DamageFactorGroupId = null;
+    this.BulletType = SCHALE.Common.FlatData.BulletType.Normal;
+    this.ArmorType = SCHALE.Common.FlatData.ArmorType.LightArmor;
+    this.DamageRate = 0;
+    this.DamageAttribute = SCHALE.Common.FlatData.DamageAttribute.Resist;
+    this.MinDamageRate = 0;
+    this.MaxDamageRate = 0;
+    this.ShowHighlightFloater = false;
+  }
 }
 
 

SCHALE.Common/FlatData/BulletArmorDamageFactorExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct BulletArmorDamageFactorExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct BulletArmorDamageFactorExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.BulletArmorDamageFactorExcelTable>(o);
   }
+  public BulletArmorDamageFactorExcelTableT UnPack() {
+    var _o = new BulletArmorDamageFactorExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(BulletArmorDamageFactorExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("BulletArmorDamageFactorExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.BulletArmorDamageFactorExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.BulletArmorDamageFactorExcelTable> Pack(FlatBufferBuilder builder, BulletArmorDamageFactorExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.BulletArmorDamageFactorExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.BulletArmorDamageFactorExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.BulletArmorDamageFactorExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateBulletArmorDamageFactorExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class BulletArmorDamageFactorExcelTableT
+{
+  public List<SCHALE.Common.FlatData.BulletArmorDamageFactorExcelT> DataList { get; set; }
+
+  public BulletArmorDamageFactorExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CafeInfoExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CafeInfoExcel : IFlatbufferObject
@@ -46,6 +47,42 @@ public struct CafeInfoExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CafeInfoExcel>(o);
   }
+  public CafeInfoExcelT UnPack() {
+    var _o = new CafeInfoExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CafeInfoExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CafeInfo");
+    _o.CafeId = TableEncryptionService.Convert(this.CafeId, key);
+    _o.IsDefault = TableEncryptionService.Convert(this.IsDefault, key);
+    _o.OpenConditionCafeId = TableEncryptionService.Convert(this.OpenConditionCafeId, key);
+    _o.OpenConditionCafeInvite = TableEncryptionService.Convert(this.OpenConditionCafeInvite, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CafeInfoExcel> Pack(FlatBufferBuilder builder, CafeInfoExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CafeInfoExcel>);
+    return CreateCafeInfoExcel(
+      builder,
+      _o.CafeId,
+      _o.IsDefault,
+      _o.OpenConditionCafeId,
+      _o.OpenConditionCafeInvite);
+  }
+}
+
+public class CafeInfoExcelT
+{
+  public long CafeId { get; set; }
+  public bool IsDefault { get; set; }
+  public SCHALE.Common.FlatData.OpenConditionContent OpenConditionCafeId { get; set; }
+  public SCHALE.Common.FlatData.OpenConditionContent OpenConditionCafeInvite { get; set; }
+
+  public CafeInfoExcelT() {
+    this.CafeId = 0;
+    this.IsDefault = false;
+    this.OpenConditionCafeId = SCHALE.Common.FlatData.OpenConditionContent.Shop;
+    this.OpenConditionCafeInvite = SCHALE.Common.FlatData.OpenConditionContent.Shop;
+  }
 }
 
 

SCHALE.Common/FlatData/CafeInfoExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CafeInfoExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CafeInfoExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CafeInfoExcelTable>(o);
   }
+  public CafeInfoExcelTableT UnPack() {
+    var _o = new CafeInfoExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CafeInfoExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CafeInfoExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CafeInfoExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CafeInfoExcelTable> Pack(FlatBufferBuilder builder, CafeInfoExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CafeInfoExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CafeInfoExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CafeInfoExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCafeInfoExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CafeInfoExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CafeInfoExcelT> DataList { get; set; }
+
+  public CafeInfoExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CafeInteractionExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CafeInteractionExcel : IFlatbufferObject
@@ -112,6 +113,87 @@ public struct CafeInteractionExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CafeInteractionExcel>(o);
   }
+  public CafeInteractionExcelT UnPack() {
+    var _o = new CafeInteractionExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CafeInteractionExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CafeInteraction");
+    _o.CharacterId = TableEncryptionService.Convert(this.CharacterId, key);
+    _o.IgnoreIfUnobtained = TableEncryptionService.Convert(this.IgnoreIfUnobtained, key);
+    _o.IgnoreIfUnobtainedStartDate = TableEncryptionService.Convert(this.IgnoreIfUnobtainedStartDate, key);
+    _o.IgnoreIfUnobtainedEndDate = TableEncryptionService.Convert(this.IgnoreIfUnobtainedEndDate, key);
+    _o.BubbleType_ = new List<SCHALE.Common.FlatData.BubbleType>();
+    for (var _j = 0; _j < this.BubbleType_Length; ++_j) {_o.BubbleType_.Add(TableEncryptionService.Convert(this.BubbleType_(_j), key));}
+    _o.BubbleDuration = new List<long>();
+    for (var _j = 0; _j < this.BubbleDurationLength; ++_j) {_o.BubbleDuration.Add(TableEncryptionService.Convert(this.BubbleDuration(_j), key));}
+    _o.FavorEmoticonRewardParcelType = TableEncryptionService.Convert(this.FavorEmoticonRewardParcelType, key);
+    _o.FavorEmoticonRewardId = TableEncryptionService.Convert(this.FavorEmoticonRewardId, key);
+    _o.FavorEmoticonRewardAmount = TableEncryptionService.Convert(this.FavorEmoticonRewardAmount, key);
+    _o.CafeCharacterState = new List<string>();
+    for (var _j = 0; _j < this.CafeCharacterStateLength; ++_j) {_o.CafeCharacterState.Add(TableEncryptionService.Convert(this.CafeCharacterState(_j), key));}
+  }
+  public static Offset<SCHALE.Common.FlatData.CafeInteractionExcel> Pack(FlatBufferBuilder builder, CafeInteractionExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CafeInteractionExcel>);
+    var _IgnoreIfUnobtainedStartDate = _o.IgnoreIfUnobtainedStartDate == null ? default(StringOffset) : builder.CreateString(_o.IgnoreIfUnobtainedStartDate);
+    var _IgnoreIfUnobtainedEndDate = _o.IgnoreIfUnobtainedEndDate == null ? default(StringOffset) : builder.CreateString(_o.IgnoreIfUnobtainedEndDate);
+    var _BubbleType_ = default(VectorOffset);
+    if (_o.BubbleType_ != null) {
+      var __BubbleType_ = _o.BubbleType_.ToArray();
+      _BubbleType_ = CreateBubbleType_Vector(builder, __BubbleType_);
+    }
+    var _BubbleDuration = default(VectorOffset);
+    if (_o.BubbleDuration != null) {
+      var __BubbleDuration = _o.BubbleDuration.ToArray();
+      _BubbleDuration = CreateBubbleDurationVector(builder, __BubbleDuration);
+    }
+    var _CafeCharacterState = default(VectorOffset);
+    if (_o.CafeCharacterState != null) {
+      var __CafeCharacterState = new StringOffset[_o.CafeCharacterState.Count];
+      for (var _j = 0; _j < __CafeCharacterState.Length; ++_j) { __CafeCharacterState[_j] = builder.CreateString(_o.CafeCharacterState[_j]); }
+      _CafeCharacterState = CreateCafeCharacterStateVector(builder, __CafeCharacterState);
+    }
+    return CreateCafeInteractionExcel(
+      builder,
+      _o.CharacterId,
+      _o.IgnoreIfUnobtained,
+      _IgnoreIfUnobtainedStartDate,
+      _IgnoreIfUnobtainedEndDate,
+      _BubbleType_,
+      _BubbleDuration,
+      _o.FavorEmoticonRewardParcelType,
+      _o.FavorEmoticonRewardId,
+      _o.FavorEmoticonRewardAmount,
+      _CafeCharacterState);
+  }
+}
+
+public class CafeInteractionExcelT
+{
+  public long CharacterId { get; set; }
+  public bool IgnoreIfUnobtained { get; set; }
+  public string IgnoreIfUnobtainedStartDate { get; set; }
+  public string IgnoreIfUnobtainedEndDate { get; set; }
+  public List<SCHALE.Common.FlatData.BubbleType> BubbleType_ { get; set; }
+  public List<long> BubbleDuration { get; set; }
+  public SCHALE.Common.FlatData.ParcelType FavorEmoticonRewardParcelType { get; set; }
+  public long FavorEmoticonRewardId { get; set; }
+  public long FavorEmoticonRewardAmount { get; set; }
+  public List<string> CafeCharacterState { get; set; }
+
+  public CafeInteractionExcelT() {
+    this.CharacterId = 0;
+    this.IgnoreIfUnobtained = false;
+    this.IgnoreIfUnobtainedStartDate = null;
+    this.IgnoreIfUnobtainedEndDate = null;
+    this.BubbleType_ = null;
+    this.BubbleDuration = null;
+    this.FavorEmoticonRewardParcelType = SCHALE.Common.FlatData.ParcelType.None;
+    this.FavorEmoticonRewardId = 0;
+    this.FavorEmoticonRewardAmount = 0;
+    this.CafeCharacterState = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CafeInteractionExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CafeInteractionExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CafeInteractionExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CafeInteractionExcelTable>(o);
   }
+  public CafeInteractionExcelTableT UnPack() {
+    var _o = new CafeInteractionExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CafeInteractionExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CafeInteractionExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CafeInteractionExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CafeInteractionExcelTable> Pack(FlatBufferBuilder builder, CafeInteractionExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CafeInteractionExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CafeInteractionExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CafeInteractionExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCafeInteractionExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CafeInteractionExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CafeInteractionExcelT> DataList { get; set; }
+
+  public CafeInteractionExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CafeProductionExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CafeProductionExcel : IFlatbufferObject
@@ -58,6 +59,54 @@ public struct CafeProductionExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CafeProductionExcel>(o);
   }
+  public CafeProductionExcelT UnPack() {
+    var _o = new CafeProductionExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CafeProductionExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CafeProduction");
+    _o.CafeId = TableEncryptionService.Convert(this.CafeId, key);
+    _o.Rank = TableEncryptionService.Convert(this.Rank, key);
+    _o.CafeProductionParcelType = TableEncryptionService.Convert(this.CafeProductionParcelType, key);
+    _o.CafeProductionParcelId = TableEncryptionService.Convert(this.CafeProductionParcelId, key);
+    _o.ParcelProductionCoefficient = TableEncryptionService.Convert(this.ParcelProductionCoefficient, key);
+    _o.ParcelProductionCorrectionValue = TableEncryptionService.Convert(this.ParcelProductionCorrectionValue, key);
+    _o.ParcelStorageMax = TableEncryptionService.Convert(this.ParcelStorageMax, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CafeProductionExcel> Pack(FlatBufferBuilder builder, CafeProductionExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CafeProductionExcel>);
+    return CreateCafeProductionExcel(
+      builder,
+      _o.CafeId,
+      _o.Rank,
+      _o.CafeProductionParcelType,
+      _o.CafeProductionParcelId,
+      _o.ParcelProductionCoefficient,
+      _o.ParcelProductionCorrectionValue,
+      _o.ParcelStorageMax);
+  }
+}
+
+public class CafeProductionExcelT
+{
+  public long CafeId { get; set; }
+  public long Rank { get; set; }
+  public SCHALE.Common.FlatData.ParcelType CafeProductionParcelType { get; set; }
+  public long CafeProductionParcelId { get; set; }
+  public long ParcelProductionCoefficient { get; set; }
+  public long ParcelProductionCorrectionValue { get; set; }
+  public long ParcelStorageMax { get; set; }
+
+  public CafeProductionExcelT() {
+    this.CafeId = 0;
+    this.Rank = 0;
+    this.CafeProductionParcelType = SCHALE.Common.FlatData.ParcelType.None;
+    this.CafeProductionParcelId = 0;
+    this.ParcelProductionCoefficient = 0;
+    this.ParcelProductionCorrectionValue = 0;
+    this.ParcelStorageMax = 0;
+  }
 }
 
 

SCHALE.Common/FlatData/CafeProductionExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CafeProductionExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CafeProductionExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CafeProductionExcelTable>(o);
   }
+  public CafeProductionExcelTableT UnPack() {
+    var _o = new CafeProductionExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CafeProductionExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CafeProductionExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CafeProductionExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CafeProductionExcelTable> Pack(FlatBufferBuilder builder, CafeProductionExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CafeProductionExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CafeProductionExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CafeProductionExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCafeProductionExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CafeProductionExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CafeProductionExcelT> DataList { get; set; }
+
+  public CafeProductionExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CafeRankExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CafeRankExcel : IFlatbufferObject
@@ -94,6 +95,78 @@ public struct CafeRankExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CafeRankExcel>(o);
   }
+  public CafeRankExcelT UnPack() {
+    var _o = new CafeRankExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CafeRankExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CafeRank");
+    _o.CafeId = TableEncryptionService.Convert(this.CafeId, key);
+    _o.Rank = TableEncryptionService.Convert(this.Rank, key);
+    _o.RecipeId = TableEncryptionService.Convert(this.RecipeId, key);
+    _o.ComfortMax = TableEncryptionService.Convert(this.ComfortMax, key);
+    _o.TagCountMax = TableEncryptionService.Convert(this.TagCountMax, key);
+    _o.CharacterVisitMin = TableEncryptionService.Convert(this.CharacterVisitMin, key);
+    _o.CharacterVisitMax = TableEncryptionService.Convert(this.CharacterVisitMax, key);
+    _o.CafeVisitWeightBase = TableEncryptionService.Convert(this.CafeVisitWeightBase, key);
+    _o.CafeVisitWeightTagBonusStep = new List<int>();
+    for (var _j = 0; _j < this.CafeVisitWeightTagBonusStepLength; ++_j) {_o.CafeVisitWeightTagBonusStep.Add(TableEncryptionService.Convert(this.CafeVisitWeightTagBonusStep(_j), key));}
+    _o.CafeVisitWeightTagBonus = new List<int>();
+    for (var _j = 0; _j < this.CafeVisitWeightTagBonusLength; ++_j) {_o.CafeVisitWeightTagBonus.Add(TableEncryptionService.Convert(this.CafeVisitWeightTagBonus(_j), key));}
+  }
+  public static Offset<SCHALE.Common.FlatData.CafeRankExcel> Pack(FlatBufferBuilder builder, CafeRankExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CafeRankExcel>);
+    var _CafeVisitWeightTagBonusStep = default(VectorOffset);
+    if (_o.CafeVisitWeightTagBonusStep != null) {
+      var __CafeVisitWeightTagBonusStep = _o.CafeVisitWeightTagBonusStep.ToArray();
+      _CafeVisitWeightTagBonusStep = CreateCafeVisitWeightTagBonusStepVector(builder, __CafeVisitWeightTagBonusStep);
+    }
+    var _CafeVisitWeightTagBonus = default(VectorOffset);
+    if (_o.CafeVisitWeightTagBonus != null) {
+      var __CafeVisitWeightTagBonus = _o.CafeVisitWeightTagBonus.ToArray();
+      _CafeVisitWeightTagBonus = CreateCafeVisitWeightTagBonusVector(builder, __CafeVisitWeightTagBonus);
+    }
+    return CreateCafeRankExcel(
+      builder,
+      _o.CafeId,
+      _o.Rank,
+      _o.RecipeId,
+      _o.ComfortMax,
+      _o.TagCountMax,
+      _o.CharacterVisitMin,
+      _o.CharacterVisitMax,
+      _o.CafeVisitWeightBase,
+      _CafeVisitWeightTagBonusStep,
+      _CafeVisitWeightTagBonus);
+  }
+}
+
+public class CafeRankExcelT
+{
+  public long CafeId { get; set; }
+  public long Rank { get; set; }
+  public long RecipeId { get; set; }
+  public long ComfortMax { get; set; }
+  public long TagCountMax { get; set; }
+  public int CharacterVisitMin { get; set; }
+  public int CharacterVisitMax { get; set; }
+  public int CafeVisitWeightBase { get; set; }
+  public List<int> CafeVisitWeightTagBonusStep { get; set; }
+  public List<int> CafeVisitWeightTagBonus { get; set; }
+
+  public CafeRankExcelT() {
+    this.CafeId = 0;
+    this.Rank = 0;
+    this.RecipeId = 0;
+    this.ComfortMax = 0;
+    this.TagCountMax = 0;
+    this.CharacterVisitMin = 0;
+    this.CharacterVisitMax = 0;
+    this.CafeVisitWeightBase = 0;
+    this.CafeVisitWeightTagBonusStep = null;
+    this.CafeVisitWeightTagBonus = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CafeRankExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CafeRankExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CafeRankExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CafeRankExcelTable>(o);
   }
+  public CafeRankExcelTableT UnPack() {
+    var _o = new CafeRankExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CafeRankExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CafeRankExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CafeRankExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CafeRankExcelTable> Pack(FlatBufferBuilder builder, CafeRankExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CafeRankExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CafeRankExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CafeRankExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCafeRankExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CafeRankExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CafeRankExcelT> DataList { get; set; }
+
+  public CafeRankExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CameraExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CameraExcel : IFlatbufferObject
@@ -74,6 +75,70 @@ public struct CameraExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CameraExcel>(o);
   }
+  public CameraExcelT UnPack() {
+    var _o = new CameraExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CameraExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("Camera");
+    _o.UniqueId = TableEncryptionService.Convert(this.UniqueId, key);
+    _o.MinDistance = TableEncryptionService.Convert(this.MinDistance, key);
+    _o.MaxDistance = TableEncryptionService.Convert(this.MaxDistance, key);
+    _o.RotationX = TableEncryptionService.Convert(this.RotationX, key);
+    _o.RotationY = TableEncryptionService.Convert(this.RotationY, key);
+    _o.MoveInstantly = TableEncryptionService.Convert(this.MoveInstantly, key);
+    _o.MoveInstantlyRotationSave = TableEncryptionService.Convert(this.MoveInstantlyRotationSave, key);
+    _o.LeftMargin = TableEncryptionService.Convert(this.LeftMargin, key);
+    _o.BottomMargin = TableEncryptionService.Convert(this.BottomMargin, key);
+    _o.IgnoreEnemies = TableEncryptionService.Convert(this.IgnoreEnemies, key);
+    _o.UseRailPointCompensation = TableEncryptionService.Convert(this.UseRailPointCompensation, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CameraExcel> Pack(FlatBufferBuilder builder, CameraExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CameraExcel>);
+    return CreateCameraExcel(
+      builder,
+      _o.UniqueId,
+      _o.MinDistance,
+      _o.MaxDistance,
+      _o.RotationX,
+      _o.RotationY,
+      _o.MoveInstantly,
+      _o.MoveInstantlyRotationSave,
+      _o.LeftMargin,
+      _o.BottomMargin,
+      _o.IgnoreEnemies,
+      _o.UseRailPointCompensation);
+  }
+}
+
+public class CameraExcelT
+{
+  public long UniqueId { get; set; }
+  public float MinDistance { get; set; }
+  public float MaxDistance { get; set; }
+  public float RotationX { get; set; }
+  public float RotationY { get; set; }
+  public bool MoveInstantly { get; set; }
+  public bool MoveInstantlyRotationSave { get; set; }
+  public float LeftMargin { get; set; }
+  public float BottomMargin { get; set; }
+  public bool IgnoreEnemies { get; set; }
+  public bool UseRailPointCompensation { get; set; }
+
+  public CameraExcelT() {
+    this.UniqueId = 0;
+    this.MinDistance = 0.0f;
+    this.MaxDistance = 0.0f;
+    this.RotationX = 0.0f;
+    this.RotationY = 0.0f;
+    this.MoveInstantly = false;
+    this.MoveInstantlyRotationSave = false;
+    this.LeftMargin = 0.0f;
+    this.BottomMargin = 0.0f;
+    this.IgnoreEnemies = false;
+    this.UseRailPointCompensation = false;
+  }
 }
 
 

SCHALE.Common/FlatData/CameraExcelTable.cs

@@ -1,56 +0,0 @@
-// <auto-generated>
-//  automatically generated by the FlatBuffers compiler, do not modify
-// </auto-generated>
-
-namespace SCHALE.Common.FlatData
-{
-
-using global::System;
-using global::System.Collections.Generic;
-using global::Google.FlatBuffers;
-
-public struct CameraExcelTable : IFlatbufferObject
-{
-  private Table __p;
-  public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
-  public static CameraExcelTable GetRootAsCameraExcelTable(ByteBuffer _bb) { return GetRootAsCameraExcelTable(_bb, new CameraExcelTable()); }
-  public static CameraExcelTable GetRootAsCameraExcelTable(ByteBuffer _bb, CameraExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
-  public CameraExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
-
-  public SCHALE.Common.FlatData.CameraExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.CameraExcel?)(new SCHALE.Common.FlatData.CameraExcel()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
-  public int DataListLength { get { int o = __p.__offset(4); return o != 0 ? __p.__vector_len(o) : 0; } }
-
-  public static Offset<SCHALE.Common.FlatData.CameraExcelTable> CreateCameraExcelTable(FlatBufferBuilder builder,
-      VectorOffset DataListOffset = default(VectorOffset)) {
-    builder.StartTable(1);
-    CameraExcelTable.AddDataList(builder, DataListOffset);
-    return CameraExcelTable.EndCameraExcelTable(builder);
-  }
-
-  public static void StartCameraExcelTable(FlatBufferBuilder builder) { builder.StartTable(1); }
-  public static void AddDataList(FlatBufferBuilder builder, VectorOffset dataListOffset) { builder.AddOffset(0, dataListOffset.Value, 0); }
-  public static VectorOffset CreateDataListVector(FlatBufferBuilder builder, Offset<SCHALE.Common.FlatData.CameraExcel>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
-  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, Offset<SCHALE.Common.FlatData.CameraExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
-  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.CameraExcel>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
-  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<SCHALE.Common.FlatData.CameraExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
-  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
-  public static Offset<SCHALE.Common.FlatData.CameraExcelTable> EndCameraExcelTable(FlatBufferBuilder builder) {
-    int o = builder.EndTable();
-    return new Offset<SCHALE.Common.FlatData.CameraExcelTable>(o);
-  }
-}
-
-
-static public class CameraExcelTableVerify
-{
-  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
-  {
-    return verifier.VerifyTableStart(tablePos)
-      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.CameraExcelVerify.Verify, false)
-      && verifier.VerifyTableEnd(tablePos);
-  }
-}
-
-}

SCHALE.Common/FlatData/CampaignChapterExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CampaignChapterExcel : IFlatbufferObject
@@ -164,6 +165,115 @@ public struct CampaignChapterExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CampaignChapterExcel>(o);
   }
+  public CampaignChapterExcelT UnPack() {
+    var _o = new CampaignChapterExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CampaignChapterExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CampaignChapter");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.Name = TableEncryptionService.Convert(this.Name, key);
+    _o.NormalImagePath = TableEncryptionService.Convert(this.NormalImagePath, key);
+    _o.HardImagePath = TableEncryptionService.Convert(this.HardImagePath, key);
+    _o.Order = TableEncryptionService.Convert(this.Order, key);
+    _o.PreChapterId = new List<long>();
+    for (var _j = 0; _j < this.PreChapterIdLength; ++_j) {_o.PreChapterId.Add(TableEncryptionService.Convert(this.PreChapterId(_j), key));}
+    _o.ChapterRewardId = TableEncryptionService.Convert(this.ChapterRewardId, key);
+    _o.ChapterHardRewardId = TableEncryptionService.Convert(this.ChapterHardRewardId, key);
+    _o.ChapterVeryHardRewardId = TableEncryptionService.Convert(this.ChapterVeryHardRewardId, key);
+    _o.NormalCampaignStageId = new List<long>();
+    for (var _j = 0; _j < this.NormalCampaignStageIdLength; ++_j) {_o.NormalCampaignStageId.Add(TableEncryptionService.Convert(this.NormalCampaignStageId(_j), key));}
+    _o.NormalExtraStageId = new List<long>();
+    for (var _j = 0; _j < this.NormalExtraStageIdLength; ++_j) {_o.NormalExtraStageId.Add(TableEncryptionService.Convert(this.NormalExtraStageId(_j), key));}
+    _o.HardCampaignStageId = new List<long>();
+    for (var _j = 0; _j < this.HardCampaignStageIdLength; ++_j) {_o.HardCampaignStageId.Add(TableEncryptionService.Convert(this.HardCampaignStageId(_j), key));}
+    _o.VeryHardCampaignStageId = new List<long>();
+    for (var _j = 0; _j < this.VeryHardCampaignStageIdLength; ++_j) {_o.VeryHardCampaignStageId.Add(TableEncryptionService.Convert(this.VeryHardCampaignStageId(_j), key));}
+    _o.IsTacticSkip = TableEncryptionService.Convert(this.IsTacticSkip, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CampaignChapterExcel> Pack(FlatBufferBuilder builder, CampaignChapterExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CampaignChapterExcel>);
+    var _Name = _o.Name == null ? default(StringOffset) : builder.CreateString(_o.Name);
+    var _NormalImagePath = _o.NormalImagePath == null ? default(StringOffset) : builder.CreateString(_o.NormalImagePath);
+    var _HardImagePath = _o.HardImagePath == null ? default(StringOffset) : builder.CreateString(_o.HardImagePath);
+    var _PreChapterId = default(VectorOffset);
+    if (_o.PreChapterId != null) {
+      var __PreChapterId = _o.PreChapterId.ToArray();
+      _PreChapterId = CreatePreChapterIdVector(builder, __PreChapterId);
+    }
+    var _NormalCampaignStageId = default(VectorOffset);
+    if (_o.NormalCampaignStageId != null) {
+      var __NormalCampaignStageId = _o.NormalCampaignStageId.ToArray();
+      _NormalCampaignStageId = CreateNormalCampaignStageIdVector(builder, __NormalCampaignStageId);
+    }
+    var _NormalExtraStageId = default(VectorOffset);
+    if (_o.NormalExtraStageId != null) {
+      var __NormalExtraStageId = _o.NormalExtraStageId.ToArray();
+      _NormalExtraStageId = CreateNormalExtraStageIdVector(builder, __NormalExtraStageId);
+    }
+    var _HardCampaignStageId = default(VectorOffset);
+    if (_o.HardCampaignStageId != null) {
+      var __HardCampaignStageId = _o.HardCampaignStageId.ToArray();
+      _HardCampaignStageId = CreateHardCampaignStageIdVector(builder, __HardCampaignStageId);
+    }
+    var _VeryHardCampaignStageId = default(VectorOffset);
+    if (_o.VeryHardCampaignStageId != null) {
+      var __VeryHardCampaignStageId = _o.VeryHardCampaignStageId.ToArray();
+      _VeryHardCampaignStageId = CreateVeryHardCampaignStageIdVector(builder, __VeryHardCampaignStageId);
+    }
+    return CreateCampaignChapterExcel(
+      builder,
+      _o.Id,
+      _Name,
+      _NormalImagePath,
+      _HardImagePath,
+      _o.Order,
+      _PreChapterId,
+      _o.ChapterRewardId,
+      _o.ChapterHardRewardId,
+      _o.ChapterVeryHardRewardId,
+      _NormalCampaignStageId,
+      _NormalExtraStageId,
+      _HardCampaignStageId,
+      _VeryHardCampaignStageId,
+      _o.IsTacticSkip);
+  }
+}
+
+public class CampaignChapterExcelT
+{
+  public long Id { get; set; }
+  public string Name { get; set; }
+  public string NormalImagePath { get; set; }
+  public string HardImagePath { get; set; }
+  public long Order { get; set; }
+  public List<long> PreChapterId { get; set; }
+  public long ChapterRewardId { get; set; }
+  public long ChapterHardRewardId { get; set; }
+  public long ChapterVeryHardRewardId { get; set; }
+  public List<long> NormalCampaignStageId { get; set; }
+  public List<long> NormalExtraStageId { get; set; }
+  public List<long> HardCampaignStageId { get; set; }
+  public List<long> VeryHardCampaignStageId { get; set; }
+  public bool IsTacticSkip { get; set; }
+
+  public CampaignChapterExcelT() {
+    this.Id = 0;
+    this.Name = null;
+    this.NormalImagePath = null;
+    this.HardImagePath = null;
+    this.Order = 0;
+    this.PreChapterId = null;
+    this.ChapterRewardId = 0;
+    this.ChapterHardRewardId = 0;
+    this.ChapterVeryHardRewardId = 0;
+    this.NormalCampaignStageId = null;
+    this.NormalExtraStageId = null;
+    this.HardCampaignStageId = null;
+    this.VeryHardCampaignStageId = null;
+    this.IsTacticSkip = false;
+  }
 }
 
 

SCHALE.Common/FlatData/CampaignChapterExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CampaignChapterExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CampaignChapterExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CampaignChapterExcelTable>(o);
   }
+  public CampaignChapterExcelTableT UnPack() {
+    var _o = new CampaignChapterExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CampaignChapterExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CampaignChapterExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CampaignChapterExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CampaignChapterExcelTable> Pack(FlatBufferBuilder builder, CampaignChapterExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CampaignChapterExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CampaignChapterExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CampaignChapterExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCampaignChapterExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CampaignChapterExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CampaignChapterExcelT> DataList { get; set; }
+
+  public CampaignChapterExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CampaignChapterRewardExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CampaignChapterRewardExcel : IFlatbufferObject
@@ -86,6 +87,64 @@ public struct CampaignChapterRewardExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CampaignChapterRewardExcel>(o);
   }
+  public CampaignChapterRewardExcelT UnPack() {
+    var _o = new CampaignChapterRewardExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CampaignChapterRewardExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CampaignChapterReward");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.CampaignChapterStar = TableEncryptionService.Convert(this.CampaignChapterStar, key);
+    _o.ChapterRewardParcelType = new List<SCHALE.Common.FlatData.ParcelType>();
+    for (var _j = 0; _j < this.ChapterRewardParcelTypeLength; ++_j) {_o.ChapterRewardParcelType.Add(TableEncryptionService.Convert(this.ChapterRewardParcelType(_j), key));}
+    _o.ChapterRewardId = new List<long>();
+    for (var _j = 0; _j < this.ChapterRewardIdLength; ++_j) {_o.ChapterRewardId.Add(TableEncryptionService.Convert(this.ChapterRewardId(_j), key));}
+    _o.ChapterRewardAmount = new List<int>();
+    for (var _j = 0; _j < this.ChapterRewardAmountLength; ++_j) {_o.ChapterRewardAmount.Add(TableEncryptionService.Convert(this.ChapterRewardAmount(_j), key));}
+  }
+  public static Offset<SCHALE.Common.FlatData.CampaignChapterRewardExcel> Pack(FlatBufferBuilder builder, CampaignChapterRewardExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CampaignChapterRewardExcel>);
+    var _ChapterRewardParcelType = default(VectorOffset);
+    if (_o.ChapterRewardParcelType != null) {
+      var __ChapterRewardParcelType = _o.ChapterRewardParcelType.ToArray();
+      _ChapterRewardParcelType = CreateChapterRewardParcelTypeVector(builder, __ChapterRewardParcelType);
+    }
+    var _ChapterRewardId = default(VectorOffset);
+    if (_o.ChapterRewardId != null) {
+      var __ChapterRewardId = _o.ChapterRewardId.ToArray();
+      _ChapterRewardId = CreateChapterRewardIdVector(builder, __ChapterRewardId);
+    }
+    var _ChapterRewardAmount = default(VectorOffset);
+    if (_o.ChapterRewardAmount != null) {
+      var __ChapterRewardAmount = _o.ChapterRewardAmount.ToArray();
+      _ChapterRewardAmount = CreateChapterRewardAmountVector(builder, __ChapterRewardAmount);
+    }
+    return CreateCampaignChapterRewardExcel(
+      builder,
+      _o.Id,
+      _o.CampaignChapterStar,
+      _ChapterRewardParcelType,
+      _ChapterRewardId,
+      _ChapterRewardAmount);
+  }
+}
+
+public class CampaignChapterRewardExcelT
+{
+  public long Id { get; set; }
+  public long CampaignChapterStar { get; set; }
+  public List<SCHALE.Common.FlatData.ParcelType> ChapterRewardParcelType { get; set; }
+  public List<long> ChapterRewardId { get; set; }
+  public List<int> ChapterRewardAmount { get; set; }
+
+  public CampaignChapterRewardExcelT() {
+    this.Id = 0;
+    this.CampaignChapterStar = 0;
+    this.ChapterRewardParcelType = null;
+    this.ChapterRewardId = null;
+    this.ChapterRewardAmount = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CampaignChapterRewardExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CampaignChapterRewardExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CampaignChapterRewardExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CampaignChapterRewardExcelTable>(o);
   }
+  public CampaignChapterRewardExcelTableT UnPack() {
+    var _o = new CampaignChapterRewardExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CampaignChapterRewardExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CampaignChapterRewardExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CampaignChapterRewardExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CampaignChapterRewardExcelTable> Pack(FlatBufferBuilder builder, CampaignChapterRewardExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CampaignChapterRewardExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CampaignChapterRewardExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CampaignChapterRewardExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCampaignChapterRewardExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CampaignChapterRewardExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CampaignChapterRewardExcelT> DataList { get; set; }
+
+  public CampaignChapterRewardExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CampaignStageExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CampaignStageExcel : IFlatbufferObject
@@ -86,18 +87,19 @@ public struct CampaignStageExcel : IFlatbufferObject
   public byte[] GetBgmIdArray() { return __p.__vector_as_array<byte>(44); }
   public SCHALE.Common.FlatData.StrategyEnvironment StrategyEnvironment { get { int o = __p.__offset(46); return o != 0 ? (SCHALE.Common.FlatData.StrategyEnvironment)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.StrategyEnvironment.None; } }
   public long GroundId { get { int o = __p.__offset(48); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public SCHALE.Common.FlatData.ContentType ContentType { get { int o = __p.__offset(50); return o != 0 ? (SCHALE.Common.FlatData.ContentType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.ContentType.None; } }
+  public int StrategySkipGroundId { get { int o = __p.__offset(50); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public long BGMId { get { int o = __p.__offset(52); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.ContentType ContentType { get { int o = __p.__offset(52); return o != 0 ? (SCHALE.Common.FlatData.ContentType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.ContentType.None; } }
-  public string FirstClearReportEventName { get { int o = __p.__offset(54); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+  public long BGMId { get { int o = __p.__offset(54); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string FirstClearReportEventName { get { int o = __p.__offset(56); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetFirstClearReportEventNameBytes() { return __p.__vector_as_span<byte>(54, 1); }
+  public Span<byte> GetFirstClearReportEventNameBytes() { return __p.__vector_as_span<byte>(56, 1); }
 #else
-  public ArraySegment<byte>? GetFirstClearReportEventNameBytes() { return __p.__vector_as_arraysegment(54); }
+  public ArraySegment<byte>? GetFirstClearReportEventNameBytes() { return __p.__vector_as_arraysegment(56); }
 #endif
-  public byte[] GetFirstClearReportEventNameArray() { return __p.__vector_as_array<byte>(54); }
+  public byte[] GetFirstClearReportEventNameArray() { return __p.__vector_as_array<byte>(56); }
-  public long TacticRewardExp { get { int o = __p.__offset(56); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long TacticRewardExp { get { int o = __p.__offset(58); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public long FixedEchelonId { get { int o = __p.__offset(58); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long FixedEchelonId { get { int o = __p.__offset(60); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public SCHALE.Common.FlatData.EchelonExtensionType EchelonExtensionType { get { int o = __p.__offset(60); return o != 0 ? (SCHALE.Common.FlatData.EchelonExtensionType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.EchelonExtensionType.Base; } }
+  public SCHALE.Common.FlatData.EchelonExtensionType EchelonExtensionType { get { int o = __p.__offset(62); return o != 0 ? (SCHALE.Common.FlatData.EchelonExtensionType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.EchelonExtensionType.Base; } }
 
   public static Offset<SCHALE.Common.FlatData.CampaignStageExcel> CreateCampaignStageExcel(FlatBufferBuilder builder,
       long Id = 0,
@@ -123,13 +125,14 @@ public struct CampaignStageExcel : IFlatbufferObject
       StringOffset BgmIdOffset = default(StringOffset),
       SCHALE.Common.FlatData.StrategyEnvironment StrategyEnvironment = SCHALE.Common.FlatData.StrategyEnvironment.None,
       long GroundId = 0,
+      int StrategySkipGroundId = 0,
       SCHALE.Common.FlatData.ContentType ContentType = SCHALE.Common.FlatData.ContentType.None,
       long BGMId = 0,
       StringOffset FirstClearReportEventNameOffset = default(StringOffset),
       long TacticRewardExp = 0,
       long FixedEchelonId = 0,
       SCHALE.Common.FlatData.EchelonExtensionType EchelonExtensionType = SCHALE.Common.FlatData.EchelonExtensionType.Base) {
-    builder.StartTable(29);
+    builder.StartTable(30);
     CampaignStageExcel.AddFixedEchelonId(builder, FixedEchelonId);
     CampaignStageExcel.AddTacticRewardExp(builder, TacticRewardExp);
     CampaignStageExcel.AddBGMId(builder, BGMId);
@@ -144,6 +147,7 @@ public struct CampaignStageExcel : IFlatbufferObject
     CampaignStageExcel.AddEchelonExtensionType(builder, EchelonExtensionType);
     CampaignStageExcel.AddFirstClearReportEventName(builder, FirstClearReportEventNameOffset);
     CampaignStageExcel.AddContentType(builder, ContentType);
+    CampaignStageExcel.AddStrategySkipGroundId(builder, StrategySkipGroundId);
     CampaignStageExcel.AddStrategyEnvironment(builder, StrategyEnvironment);
     CampaignStageExcel.AddBgmId(builder, BgmIdOffset);
     CampaignStageExcel.AddRecommandLevel(builder, RecommandLevel);
@@ -162,7 +166,7 @@ public struct CampaignStageExcel : IFlatbufferObject
     return CampaignStageExcel.EndCampaignStageExcel(builder);
   }
 
-  public static void StartCampaignStageExcel(FlatBufferBuilder builder) { builder.StartTable(29); }
+  public static void StartCampaignStageExcel(FlatBufferBuilder builder) { builder.StartTable(30); }
   public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
   public static void AddDeprecated(FlatBufferBuilder builder, bool deprecated) { builder.AddBool(1, deprecated, false); }
   public static void AddName(FlatBufferBuilder builder, StringOffset nameOffset) { builder.AddOffset(2, nameOffset.Value, 0); }
@@ -196,16 +200,175 @@ public struct CampaignStageExcel : IFlatbufferObject
   public static void AddBgmId(FlatBufferBuilder builder, StringOffset bgmIdOffset) { builder.AddOffset(20, bgmIdOffset.Value, 0); }
   public static void AddStrategyEnvironment(FlatBufferBuilder builder, SCHALE.Common.FlatData.StrategyEnvironment strategyEnvironment) { builder.AddInt(21, (int)strategyEnvironment, 0); }
   public static void AddGroundId(FlatBufferBuilder builder, long groundId) { builder.AddLong(22, groundId, 0); }
-  public static void AddContentType(FlatBufferBuilder builder, SCHALE.Common.FlatData.ContentType contentType) { builder.AddInt(23, (int)contentType, 0); }
+  public static void AddStrategySkipGroundId(FlatBufferBuilder builder, int strategySkipGroundId) { builder.AddInt(23, strategySkipGroundId, 0); }
-  public static void AddBGMId(FlatBufferBuilder builder, long bGMId) { builder.AddLong(24, bGMId, 0); }
+  public static void AddContentType(FlatBufferBuilder builder, SCHALE.Common.FlatData.ContentType contentType) { builder.AddInt(24, (int)contentType, 0); }
-  public static void AddFirstClearReportEventName(FlatBufferBuilder builder, StringOffset firstClearReportEventNameOffset) { builder.AddOffset(25, firstClearReportEventNameOffset.Value, 0); }
+  public static void AddBGMId(FlatBufferBuilder builder, long bGMId) { builder.AddLong(25, bGMId, 0); }
-  public static void AddTacticRewardExp(FlatBufferBuilder builder, long tacticRewardExp) { builder.AddLong(26, tacticRewardExp, 0); }
+  public static void AddFirstClearReportEventName(FlatBufferBuilder builder, StringOffset firstClearReportEventNameOffset) { builder.AddOffset(26, firstClearReportEventNameOffset.Value, 0); }
-  public static void AddFixedEchelonId(FlatBufferBuilder builder, long fixedEchelonId) { builder.AddLong(27, fixedEchelonId, 0); }
+  public static void AddTacticRewardExp(FlatBufferBuilder builder, long tacticRewardExp) { builder.AddLong(27, tacticRewardExp, 0); }
-  public static void AddEchelonExtensionType(FlatBufferBuilder builder, SCHALE.Common.FlatData.EchelonExtensionType echelonExtensionType) { builder.AddInt(28, (int)echelonExtensionType, 0); }
+  public static void AddFixedEchelonId(FlatBufferBuilder builder, long fixedEchelonId) { builder.AddLong(28, fixedEchelonId, 0); }
+  public static void AddEchelonExtensionType(FlatBufferBuilder builder, SCHALE.Common.FlatData.EchelonExtensionType echelonExtensionType) { builder.AddInt(29, (int)echelonExtensionType, 0); }
   public static Offset<SCHALE.Common.FlatData.CampaignStageExcel> EndCampaignStageExcel(FlatBufferBuilder builder) {
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CampaignStageExcel>(o);
   }
+  public CampaignStageExcelT UnPack() {
+    var _o = new CampaignStageExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CampaignStageExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CampaignStage");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.Deprecated = TableEncryptionService.Convert(this.Deprecated, key);
+    _o.Name = TableEncryptionService.Convert(this.Name, key);
+    _o.StageNumber = TableEncryptionService.Convert(this.StageNumber, key);
+    _o.CleardScenarioId = TableEncryptionService.Convert(this.CleardScenarioId, key);
+    _o.BattleDuration = TableEncryptionService.Convert(this.BattleDuration, key);
+    _o.StageEnterCostType = TableEncryptionService.Convert(this.StageEnterCostType, key);
+    _o.StageEnterCostId = TableEncryptionService.Convert(this.StageEnterCostId, key);
+    _o.StageEnterCostAmount = TableEncryptionService.Convert(this.StageEnterCostAmount, key);
+    _o.StageEnterEchelonCount = TableEncryptionService.Convert(this.StageEnterEchelonCount, key);
+    _o.StarConditionTacticRankSCount = TableEncryptionService.Convert(this.StarConditionTacticRankSCount, key);
+    _o.StarConditionTurnCount = TableEncryptionService.Convert(this.StarConditionTurnCount, key);
+    _o.EnterScenarioGroupId = new List<long>();
+    for (var _j = 0; _j < this.EnterScenarioGroupIdLength; ++_j) {_o.EnterScenarioGroupId.Add(TableEncryptionService.Convert(this.EnterScenarioGroupId(_j), key));}
+    _o.ClearScenarioGroupId = new List<long>();
+    for (var _j = 0; _j < this.ClearScenarioGroupIdLength; ++_j) {_o.ClearScenarioGroupId.Add(TableEncryptionService.Convert(this.ClearScenarioGroupId(_j), key));}
+    _o.StrategyMap = TableEncryptionService.Convert(this.StrategyMap, key);
+    _o.StrategyMapBG = TableEncryptionService.Convert(this.StrategyMapBG, key);
+    _o.CampaignStageRewardId = TableEncryptionService.Convert(this.CampaignStageRewardId, key);
+    _o.MaxTurn = TableEncryptionService.Convert(this.MaxTurn, key);
+    _o.StageTopography = TableEncryptionService.Convert(this.StageTopography, key);
+    _o.RecommandLevel = TableEncryptionService.Convert(this.RecommandLevel, key);
+    _o.BgmId = TableEncryptionService.Convert(this.BgmId, key);
+    _o.StrategyEnvironment = TableEncryptionService.Convert(this.StrategyEnvironment, key);
+    _o.GroundId = TableEncryptionService.Convert(this.GroundId, key);
+    _o.StrategySkipGroundId = TableEncryptionService.Convert(this.StrategySkipGroundId, key);
+    _o.ContentType = TableEncryptionService.Convert(this.ContentType, key);
+    _o.BGMId = TableEncryptionService.Convert(this.BGMId, key);
+    _o.FirstClearReportEventName = TableEncryptionService.Convert(this.FirstClearReportEventName, key);
+    _o.TacticRewardExp = TableEncryptionService.Convert(this.TacticRewardExp, key);
+    _o.FixedEchelonId = TableEncryptionService.Convert(this.FixedEchelonId, key);
+    _o.EchelonExtensionType = TableEncryptionService.Convert(this.EchelonExtensionType, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CampaignStageExcel> Pack(FlatBufferBuilder builder, CampaignStageExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CampaignStageExcel>);
+    var _Name = _o.Name == null ? default(StringOffset) : builder.CreateString(_o.Name);
+    var _StageNumber = _o.StageNumber == null ? default(StringOffset) : builder.CreateString(_o.StageNumber);
+    var _EnterScenarioGroupId = default(VectorOffset);
+    if (_o.EnterScenarioGroupId != null) {
+      var __EnterScenarioGroupId = _o.EnterScenarioGroupId.ToArray();
+      _EnterScenarioGroupId = CreateEnterScenarioGroupIdVector(builder, __EnterScenarioGroupId);
+    }
+    var _ClearScenarioGroupId = default(VectorOffset);
+    if (_o.ClearScenarioGroupId != null) {
+      var __ClearScenarioGroupId = _o.ClearScenarioGroupId.ToArray();
+      _ClearScenarioGroupId = CreateClearScenarioGroupIdVector(builder, __ClearScenarioGroupId);
+    }
+    var _StrategyMap = _o.StrategyMap == null ? default(StringOffset) : builder.CreateString(_o.StrategyMap);
+    var _StrategyMapBG = _o.StrategyMapBG == null ? default(StringOffset) : builder.CreateString(_o.StrategyMapBG);
+    var _BgmId = _o.BgmId == null ? default(StringOffset) : builder.CreateString(_o.BgmId);
+    var _FirstClearReportEventName = _o.FirstClearReportEventName == null ? default(StringOffset) : builder.CreateString(_o.FirstClearReportEventName);
+    return CreateCampaignStageExcel(
+      builder,
+      _o.Id,
+      _o.Deprecated,
+      _Name,
+      _StageNumber,
+      _o.CleardScenarioId,
+      _o.BattleDuration,
+      _o.StageEnterCostType,
+      _o.StageEnterCostId,
+      _o.StageEnterCostAmount,
+      _o.StageEnterEchelonCount,
+      _o.StarConditionTacticRankSCount,
+      _o.StarConditionTurnCount,
+      _EnterScenarioGroupId,
+      _ClearScenarioGroupId,
+      _StrategyMap,
+      _StrategyMapBG,
+      _o.CampaignStageRewardId,
+      _o.MaxTurn,
+      _o.StageTopography,
+      _o.RecommandLevel,
+      _BgmId,
+      _o.StrategyEnvironment,
+      _o.GroundId,
+      _o.StrategySkipGroundId,
+      _o.ContentType,
+      _o.BGMId,
+      _FirstClearReportEventName,
+      _o.TacticRewardExp,
+      _o.FixedEchelonId,
+      _o.EchelonExtensionType);
+  }
+}
+
+public class CampaignStageExcelT
+{
+  public long Id { get; set; }
+  public bool Deprecated { get; set; }
+  public string Name { get; set; }
+  public string StageNumber { get; set; }
+  public long CleardScenarioId { get; set; }
+  public long BattleDuration { get; set; }
+  public SCHALE.Common.FlatData.ParcelType StageEnterCostType { get; set; }
+  public long StageEnterCostId { get; set; }
+  public int StageEnterCostAmount { get; set; }
+  public int StageEnterEchelonCount { get; set; }
+  public long StarConditionTacticRankSCount { get; set; }
+  public long StarConditionTurnCount { get; set; }
+  public List<long> EnterScenarioGroupId { get; set; }
+  public List<long> ClearScenarioGroupId { get; set; }
+  public string StrategyMap { get; set; }
+  public string StrategyMapBG { get; set; }
+  public long CampaignStageRewardId { get; set; }
+  public int MaxTurn { get; set; }
+  public SCHALE.Common.FlatData.StageTopography StageTopography { get; set; }
+  public int RecommandLevel { get; set; }
+  public string BgmId { get; set; }
+  public SCHALE.Common.FlatData.StrategyEnvironment StrategyEnvironment { get; set; }
+  public long GroundId { get; set; }
+  public int StrategySkipGroundId { get; set; }
+  public SCHALE.Common.FlatData.ContentType ContentType { get; set; }
+  public long BGMId { get; set; }
+  public string FirstClearReportEventName { get; set; }
+  public long TacticRewardExp { get; set; }
+  public long FixedEchelonId { get; set; }
+  public SCHALE.Common.FlatData.EchelonExtensionType EchelonExtensionType { get; set; }
+
+  public CampaignStageExcelT() {
+    this.Id = 0;
+    this.Deprecated = false;
+    this.Name = null;
+    this.StageNumber = null;
+    this.CleardScenarioId = 0;
+    this.BattleDuration = 0;
+    this.StageEnterCostType = SCHALE.Common.FlatData.ParcelType.None;
+    this.StageEnterCostId = 0;
+    this.StageEnterCostAmount = 0;
+    this.StageEnterEchelonCount = 0;
+    this.StarConditionTacticRankSCount = 0;
+    this.StarConditionTurnCount = 0;
+    this.EnterScenarioGroupId = null;
+    this.ClearScenarioGroupId = null;
+    this.StrategyMap = null;
+    this.StrategyMapBG = null;
+    this.CampaignStageRewardId = 0;
+    this.MaxTurn = 0;
+    this.StageTopography = SCHALE.Common.FlatData.StageTopography.Street;
+    this.RecommandLevel = 0;
+    this.BgmId = null;
+    this.StrategyEnvironment = SCHALE.Common.FlatData.StrategyEnvironment.None;
+    this.GroundId = 0;
+    this.StrategySkipGroundId = 0;
+    this.ContentType = SCHALE.Common.FlatData.ContentType.None;
+    this.BGMId = 0;
+    this.FirstClearReportEventName = null;
+    this.TacticRewardExp = 0;
+    this.FixedEchelonId = 0;
+    this.EchelonExtensionType = SCHALE.Common.FlatData.EchelonExtensionType.Base;
+  }
 }
 
 
@@ -237,12 +400,13 @@ static public class CampaignStageExcelVerify
       && verifier.VerifyString(tablePos, 44 /*BgmId*/, false)
       && verifier.VerifyField(tablePos, 46 /*StrategyEnvironment*/, 4 /*SCHALE.Common.FlatData.StrategyEnvironment*/, 4, false)
       && verifier.VerifyField(tablePos, 48 /*GroundId*/, 8 /*long*/, 8, false)
-      && verifier.VerifyField(tablePos, 50 /*ContentType*/, 4 /*SCHALE.Common.FlatData.ContentType*/, 4, false)
+      && verifier.VerifyField(tablePos, 50 /*StrategySkipGroundId*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 52 /*BGMId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 52 /*ContentType*/, 4 /*SCHALE.Common.FlatData.ContentType*/, 4, false)
-      && verifier.VerifyString(tablePos, 54 /*FirstClearReportEventName*/, false)
+      && verifier.VerifyField(tablePos, 54 /*BGMId*/, 8 /*long*/, 8, false)
-      && verifier.VerifyField(tablePos, 56 /*TacticRewardExp*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 56 /*FirstClearReportEventName*/, false)
-      && verifier.VerifyField(tablePos, 58 /*FixedEchelonId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 58 /*TacticRewardExp*/, 8 /*long*/, 8, false)
-      && verifier.VerifyField(tablePos, 60 /*EchelonExtensionType*/, 4 /*SCHALE.Common.FlatData.EchelonExtensionType*/, 4, false)
+      && verifier.VerifyField(tablePos, 60 /*FixedEchelonId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 62 /*EchelonExtensionType*/, 4 /*SCHALE.Common.FlatData.EchelonExtensionType*/, 4, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }

SCHALE.Common/FlatData/CampaignStageExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CampaignStageExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CampaignStageExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CampaignStageExcelTable>(o);
   }
+  public CampaignStageExcelTableT UnPack() {
+    var _o = new CampaignStageExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CampaignStageExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CampaignStageExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CampaignStageExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CampaignStageExcelTable> Pack(FlatBufferBuilder builder, CampaignStageExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CampaignStageExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CampaignStageExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CampaignStageExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCampaignStageExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CampaignStageExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CampaignStageExcelT> DataList { get; set; }
+
+  public CampaignStageExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CampaignStageRewardExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CampaignStageRewardExcel : IFlatbufferObject
@@ -58,6 +59,54 @@ public struct CampaignStageRewardExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CampaignStageRewardExcel>(o);
   }
+  public CampaignStageRewardExcelT UnPack() {
+    var _o = new CampaignStageRewardExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CampaignStageRewardExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CampaignStageReward");
+    _o.GroupId = TableEncryptionService.Convert(this.GroupId, key);
+    _o.RewardTag = TableEncryptionService.Convert(this.RewardTag, key);
+    _o.StageRewardProb = TableEncryptionService.Convert(this.StageRewardProb, key);
+    _o.StageRewardParcelType = TableEncryptionService.Convert(this.StageRewardParcelType, key);
+    _o.StageRewardId = TableEncryptionService.Convert(this.StageRewardId, key);
+    _o.StageRewardAmount = TableEncryptionService.Convert(this.StageRewardAmount, key);
+    _o.IsDisplayed = TableEncryptionService.Convert(this.IsDisplayed, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CampaignStageRewardExcel> Pack(FlatBufferBuilder builder, CampaignStageRewardExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CampaignStageRewardExcel>);
+    return CreateCampaignStageRewardExcel(
+      builder,
+      _o.GroupId,
+      _o.RewardTag,
+      _o.StageRewardProb,
+      _o.StageRewardParcelType,
+      _o.StageRewardId,
+      _o.StageRewardAmount,
+      _o.IsDisplayed);
+  }
+}
+
+public class CampaignStageRewardExcelT
+{
+  public long GroupId { get; set; }
+  public SCHALE.Common.FlatData.RewardTag RewardTag { get; set; }
+  public int StageRewardProb { get; set; }
+  public SCHALE.Common.FlatData.ParcelType StageRewardParcelType { get; set; }
+  public long StageRewardId { get; set; }
+  public int StageRewardAmount { get; set; }
+  public bool IsDisplayed { get; set; }
+
+  public CampaignStageRewardExcelT() {
+    this.GroupId = 0;
+    this.RewardTag = SCHALE.Common.FlatData.RewardTag.Default;
+    this.StageRewardProb = 0;
+    this.StageRewardParcelType = SCHALE.Common.FlatData.ParcelType.None;
+    this.StageRewardId = 0;
+    this.StageRewardAmount = 0;
+    this.IsDisplayed = false;
+  }
 }
 
 

SCHALE.Common/FlatData/CampaignStageRewardExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CampaignStageRewardExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CampaignStageRewardExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CampaignStageRewardExcelTable>(o);
   }
+  public CampaignStageRewardExcelTableT UnPack() {
+    var _o = new CampaignStageRewardExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CampaignStageRewardExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CampaignStageRewardExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CampaignStageRewardExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CampaignStageRewardExcelTable> Pack(FlatBufferBuilder builder, CampaignStageRewardExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CampaignStageRewardExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CampaignStageRewardExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CampaignStageRewardExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCampaignStageRewardExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CampaignStageRewardExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CampaignStageRewardExcelT> DataList { get; set; }
+
+  public CampaignStageRewardExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CampaignStrategyObjectExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CampaignStrategyObjectExcel : IFlatbufferObject
@@ -108,6 +109,89 @@ public struct CampaignStrategyObjectExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CampaignStrategyObjectExcel>(o);
   }
+  public CampaignStrategyObjectExcelT UnPack() {
+    var _o = new CampaignStrategyObjectExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CampaignStrategyObjectExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CampaignStrategyObject");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.Key = TableEncryptionService.Convert(this.Key, key);
+    _o.Name = TableEncryptionService.Convert(this.Name, key);
+    _o.PrefabName = TableEncryptionService.Convert(this.PrefabName, key);
+    _o.StrategyObjectType = TableEncryptionService.Convert(this.StrategyObjectType, key);
+    _o.StrategyRewardParcelType = TableEncryptionService.Convert(this.StrategyRewardParcelType, key);
+    _o.StrategyRewardID = TableEncryptionService.Convert(this.StrategyRewardID, key);
+    _o.StrategyRewardName = TableEncryptionService.Convert(this.StrategyRewardName, key);
+    _o.StrategyRewardAmount = TableEncryptionService.Convert(this.StrategyRewardAmount, key);
+    _o.StrategySightRange = TableEncryptionService.Convert(this.StrategySightRange, key);
+    _o.PortalId = TableEncryptionService.Convert(this.PortalId, key);
+    _o.HealValue = TableEncryptionService.Convert(this.HealValue, key);
+    _o.SwithId = TableEncryptionService.Convert(this.SwithId, key);
+    _o.BuffId = TableEncryptionService.Convert(this.BuffId, key);
+    _o.Disposable = TableEncryptionService.Convert(this.Disposable, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CampaignStrategyObjectExcel> Pack(FlatBufferBuilder builder, CampaignStrategyObjectExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CampaignStrategyObjectExcel>);
+    var _Name = _o.Name == null ? default(StringOffset) : builder.CreateString(_o.Name);
+    var _PrefabName = _o.PrefabName == null ? default(StringOffset) : builder.CreateString(_o.PrefabName);
+    var _StrategyRewardName = _o.StrategyRewardName == null ? default(StringOffset) : builder.CreateString(_o.StrategyRewardName);
+    return CreateCampaignStrategyObjectExcel(
+      builder,
+      _o.Id,
+      _o.Key,
+      _Name,
+      _PrefabName,
+      _o.StrategyObjectType,
+      _o.StrategyRewardParcelType,
+      _o.StrategyRewardID,
+      _StrategyRewardName,
+      _o.StrategyRewardAmount,
+      _o.StrategySightRange,
+      _o.PortalId,
+      _o.HealValue,
+      _o.SwithId,
+      _o.BuffId,
+      _o.Disposable);
+  }
+}
+
+public class CampaignStrategyObjectExcelT
+{
+  public long Id { get; set; }
+  public uint Key { get; set; }
+  public string Name { get; set; }
+  public string PrefabName { get; set; }
+  public SCHALE.Common.FlatData.StrategyObjectType StrategyObjectType { get; set; }
+  public SCHALE.Common.FlatData.ParcelType StrategyRewardParcelType { get; set; }
+  public long StrategyRewardID { get; set; }
+  public string StrategyRewardName { get; set; }
+  public int StrategyRewardAmount { get; set; }
+  public long StrategySightRange { get; set; }
+  public int PortalId { get; set; }
+  public int HealValue { get; set; }
+  public int SwithId { get; set; }
+  public int BuffId { get; set; }
+  public bool Disposable { get; set; }
+
+  public CampaignStrategyObjectExcelT() {
+    this.Id = 0;
+    this.Key = 0;
+    this.Name = null;
+    this.PrefabName = null;
+    this.StrategyObjectType = SCHALE.Common.FlatData.StrategyObjectType.None;
+    this.StrategyRewardParcelType = SCHALE.Common.FlatData.ParcelType.None;
+    this.StrategyRewardID = 0;
+    this.StrategyRewardName = null;
+    this.StrategyRewardAmount = 0;
+    this.StrategySightRange = 0;
+    this.PortalId = 0;
+    this.HealValue = 0;
+    this.SwithId = 0;
+    this.BuffId = 0;
+    this.Disposable = false;
+  }
 }
 
 

SCHALE.Common/FlatData/CampaignStrategyObjectExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CampaignStrategyObjectExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CampaignStrategyObjectExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CampaignStrategyObjectExcelTable>(o);
   }
+  public CampaignStrategyObjectExcelTableT UnPack() {
+    var _o = new CampaignStrategyObjectExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CampaignStrategyObjectExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CampaignStrategyObjectExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CampaignStrategyObjectExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CampaignStrategyObjectExcelTable> Pack(FlatBufferBuilder builder, CampaignStrategyObjectExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CampaignStrategyObjectExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CampaignStrategyObjectExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CampaignStrategyObjectExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCampaignStrategyObjectExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CampaignStrategyObjectExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CampaignStrategyObjectExcelT> DataList { get; set; }
+
+  public CampaignStrategyObjectExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CampaignUnitExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CampaignUnitExcel : IFlatbufferObject
@@ -128,6 +129,97 @@ public struct CampaignUnitExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CampaignUnitExcel>(o);
   }
+  public CampaignUnitExcelT UnPack() {
+    var _o = new CampaignUnitExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CampaignUnitExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CampaignUnit");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.Key = TableEncryptionService.Convert(this.Key, key);
+    _o.Name = TableEncryptionService.Convert(this.Name, key);
+    _o.PrefabName = TableEncryptionService.Convert(this.PrefabName, key);
+    _o.StrategyPrefabName = TableEncryptionService.Convert(this.StrategyPrefabName, key);
+    _o.EnterScenarioGroupId = new List<long>();
+    for (var _j = 0; _j < this.EnterScenarioGroupIdLength; ++_j) {_o.EnterScenarioGroupId.Add(TableEncryptionService.Convert(this.EnterScenarioGroupId(_j), key));}
+    _o.ClearScenarioGroupId = new List<long>();
+    for (var _j = 0; _j < this.ClearScenarioGroupIdLength; ++_j) {_o.ClearScenarioGroupId.Add(TableEncryptionService.Convert(this.ClearScenarioGroupId(_j), key));}
+    _o.GroundId = TableEncryptionService.Convert(this.GroundId, key);
+    _o.MoveRange = TableEncryptionService.Convert(this.MoveRange, key);
+    _o.AIMoveType = TableEncryptionService.Convert(this.AIMoveType, key);
+    _o.Grade = TableEncryptionService.Convert(this.Grade, key);
+    _o.EnvironmentType = TableEncryptionService.Convert(this.EnvironmentType, key);
+    _o.Scale = TableEncryptionService.Convert(this.Scale, key);
+    _o.IsTacticSkip = TableEncryptionService.Convert(this.IsTacticSkip, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CampaignUnitExcel> Pack(FlatBufferBuilder builder, CampaignUnitExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CampaignUnitExcel>);
+    var _Name = _o.Name == null ? default(StringOffset) : builder.CreateString(_o.Name);
+    var _PrefabName = _o.PrefabName == null ? default(StringOffset) : builder.CreateString(_o.PrefabName);
+    var _StrategyPrefabName = _o.StrategyPrefabName == null ? default(StringOffset) : builder.CreateString(_o.StrategyPrefabName);
+    var _EnterScenarioGroupId = default(VectorOffset);
+    if (_o.EnterScenarioGroupId != null) {
+      var __EnterScenarioGroupId = _o.EnterScenarioGroupId.ToArray();
+      _EnterScenarioGroupId = CreateEnterScenarioGroupIdVector(builder, __EnterScenarioGroupId);
+    }
+    var _ClearScenarioGroupId = default(VectorOffset);
+    if (_o.ClearScenarioGroupId != null) {
+      var __ClearScenarioGroupId = _o.ClearScenarioGroupId.ToArray();
+      _ClearScenarioGroupId = CreateClearScenarioGroupIdVector(builder, __ClearScenarioGroupId);
+    }
+    return CreateCampaignUnitExcel(
+      builder,
+      _o.Id,
+      _o.Key,
+      _Name,
+      _PrefabName,
+      _StrategyPrefabName,
+      _EnterScenarioGroupId,
+      _ClearScenarioGroupId,
+      _o.GroundId,
+      _o.MoveRange,
+      _o.AIMoveType,
+      _o.Grade,
+      _o.EnvironmentType,
+      _o.Scale,
+      _o.IsTacticSkip);
+  }
+}
+
+public class CampaignUnitExcelT
+{
+  public long Id { get; set; }
+  public uint Key { get; set; }
+  public string Name { get; set; }
+  public string PrefabName { get; set; }
+  public string StrategyPrefabName { get; set; }
+  public List<long> EnterScenarioGroupId { get; set; }
+  public List<long> ClearScenarioGroupId { get; set; }
+  public long GroundId { get; set; }
+  public int MoveRange { get; set; }
+  public SCHALE.Common.FlatData.StrategyAIType AIMoveType { get; set; }
+  public SCHALE.Common.FlatData.HexaUnitGrade Grade { get; set; }
+  public SCHALE.Common.FlatData.TacticEnvironment EnvironmentType { get; set; }
+  public float Scale { get; set; }
+  public bool IsTacticSkip { get; set; }
+
+  public CampaignUnitExcelT() {
+    this.Id = 0;
+    this.Key = 0;
+    this.Name = null;
+    this.PrefabName = null;
+    this.StrategyPrefabName = null;
+    this.EnterScenarioGroupId = null;
+    this.ClearScenarioGroupId = null;
+    this.GroundId = 0;
+    this.MoveRange = 0;
+    this.AIMoveType = SCHALE.Common.FlatData.StrategyAIType.None;
+    this.Grade = SCHALE.Common.FlatData.HexaUnitGrade.Grade1;
+    this.EnvironmentType = SCHALE.Common.FlatData.TacticEnvironment.None;
+    this.Scale = 0.0f;
+    this.IsTacticSkip = false;
+  }
 }
 
 

SCHALE.Common/FlatData/CampaignUnitExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CampaignUnitExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CampaignUnitExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CampaignUnitExcelTable>(o);
   }
+  public CampaignUnitExcelTableT UnPack() {
+    var _o = new CampaignUnitExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CampaignUnitExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CampaignUnitExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CampaignUnitExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CampaignUnitExcelTable> Pack(FlatBufferBuilder builder, CampaignUnitExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CampaignUnitExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CampaignUnitExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CampaignUnitExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCampaignUnitExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CampaignUnitExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CampaignUnitExcelT> DataList { get; set; }
+
+  public CampaignUnitExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CharacterAIExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CharacterAIExcel : IFlatbufferObject
@@ -78,6 +79,74 @@ public struct CharacterAIExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterAIExcel>(o);
   }
+  public CharacterAIExcelT UnPack() {
+    var _o = new CharacterAIExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterAIExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterAI");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.EngageType = TableEncryptionService.Convert(this.EngageType, key);
+    _o.Positioning = TableEncryptionService.Convert(this.Positioning, key);
+    _o.CheckCanUseAutoSkill = TableEncryptionService.Convert(this.CheckCanUseAutoSkill, key);
+    _o.DistanceReduceRatioObstaclePath = TableEncryptionService.Convert(this.DistanceReduceRatioObstaclePath, key);
+    _o.DistanceReduceObstaclePath = TableEncryptionService.Convert(this.DistanceReduceObstaclePath, key);
+    _o.DistanceReduceRatioFormationPath = TableEncryptionService.Convert(this.DistanceReduceRatioFormationPath, key);
+    _o.DistanceReduceFormationPath = TableEncryptionService.Convert(this.DistanceReduceFormationPath, key);
+    _o.MinimumPositionGap = TableEncryptionService.Convert(this.MinimumPositionGap, key);
+    _o.CanUseObstacleOfKneelMotion = TableEncryptionService.Convert(this.CanUseObstacleOfKneelMotion, key);
+    _o.CanUseObstacleOfStandMotion = TableEncryptionService.Convert(this.CanUseObstacleOfStandMotion, key);
+    _o.HasTargetSwitchingMotion = TableEncryptionService.Convert(this.HasTargetSwitchingMotion, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterAIExcel> Pack(FlatBufferBuilder builder, CharacterAIExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterAIExcel>);
+    return CreateCharacterAIExcel(
+      builder,
+      _o.Id,
+      _o.EngageType,
+      _o.Positioning,
+      _o.CheckCanUseAutoSkill,
+      _o.DistanceReduceRatioObstaclePath,
+      _o.DistanceReduceObstaclePath,
+      _o.DistanceReduceRatioFormationPath,
+      _o.DistanceReduceFormationPath,
+      _o.MinimumPositionGap,
+      _o.CanUseObstacleOfKneelMotion,
+      _o.CanUseObstacleOfStandMotion,
+      _o.HasTargetSwitchingMotion);
+  }
+}
+
+public class CharacterAIExcelT
+{
+  public long Id { get; set; }
+  public SCHALE.Common.FlatData.EngageType EngageType { get; set; }
+  public SCHALE.Common.FlatData.PositioningType Positioning { get; set; }
+  public bool CheckCanUseAutoSkill { get; set; }
+  public long DistanceReduceRatioObstaclePath { get; set; }
+  public long DistanceReduceObstaclePath { get; set; }
+  public long DistanceReduceRatioFormationPath { get; set; }
+  public long DistanceReduceFormationPath { get; set; }
+  public long MinimumPositionGap { get; set; }
+  public bool CanUseObstacleOfKneelMotion { get; set; }
+  public bool CanUseObstacleOfStandMotion { get; set; }
+  public bool HasTargetSwitchingMotion { get; set; }
+
+  public CharacterAIExcelT() {
+    this.Id = 0;
+    this.EngageType = SCHALE.Common.FlatData.EngageType.SearchAndMove;
+    this.Positioning = SCHALE.Common.FlatData.PositioningType.CloseToObstacle;
+    this.CheckCanUseAutoSkill = false;
+    this.DistanceReduceRatioObstaclePath = 0;
+    this.DistanceReduceObstaclePath = 0;
+    this.DistanceReduceRatioFormationPath = 0;
+    this.DistanceReduceFormationPath = 0;
+    this.MinimumPositionGap = 0;
+    this.CanUseObstacleOfKneelMotion = false;
+    this.CanUseObstacleOfStandMotion = false;
+    this.HasTargetSwitchingMotion = false;
+  }
 }
 
 

SCHALE.Common/FlatData/CharacterAIExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CharacterAIExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CharacterAIExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterAIExcelTable>(o);
   }
+  public CharacterAIExcelTableT UnPack() {
+    var _o = new CharacterAIExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterAIExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterAIExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CharacterAIExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterAIExcelTable> Pack(FlatBufferBuilder builder, CharacterAIExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterAIExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CharacterAIExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CharacterAIExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCharacterAIExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CharacterAIExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CharacterAIExcelT> DataList { get; set; }
+
+  public CharacterAIExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CharacterAcademyTagsExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CharacterAcademyTagsExcel : IFlatbufferObject
@@ -114,6 +115,80 @@ public struct CharacterAcademyTagsExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterAcademyTagsExcel>(o);
   }
+  public CharacterAcademyTagsExcelT UnPack() {
+    var _o = new CharacterAcademyTagsExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterAcademyTagsExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterAcademyTags");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.FavorTags = new List<SCHALE.Common.FlatData.Tag>();
+    for (var _j = 0; _j < this.FavorTagsLength; ++_j) {_o.FavorTags.Add(TableEncryptionService.Convert(this.FavorTags(_j), key));}
+    _o.FavorItemTags = new List<SCHALE.Common.FlatData.Tag>();
+    for (var _j = 0; _j < this.FavorItemTagsLength; ++_j) {_o.FavorItemTags.Add(TableEncryptionService.Convert(this.FavorItemTags(_j), key));}
+    _o.FavorItemUniqueTags = new List<SCHALE.Common.FlatData.Tag>();
+    for (var _j = 0; _j < this.FavorItemUniqueTagsLength; ++_j) {_o.FavorItemUniqueTags.Add(TableEncryptionService.Convert(this.FavorItemUniqueTags(_j), key));}
+    _o.ForbiddenTags = new List<SCHALE.Common.FlatData.Tag>();
+    for (var _j = 0; _j < this.ForbiddenTagsLength; ++_j) {_o.ForbiddenTags.Add(TableEncryptionService.Convert(this.ForbiddenTags(_j), key));}
+    _o.ZoneWhiteListTags = new List<SCHALE.Common.FlatData.Tag>();
+    for (var _j = 0; _j < this.ZoneWhiteListTagsLength; ++_j) {_o.ZoneWhiteListTags.Add(TableEncryptionService.Convert(this.ZoneWhiteListTags(_j), key));}
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterAcademyTagsExcel> Pack(FlatBufferBuilder builder, CharacterAcademyTagsExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterAcademyTagsExcel>);
+    var _FavorTags = default(VectorOffset);
+    if (_o.FavorTags != null) {
+      var __FavorTags = _o.FavorTags.ToArray();
+      _FavorTags = CreateFavorTagsVector(builder, __FavorTags);
+    }
+    var _FavorItemTags = default(VectorOffset);
+    if (_o.FavorItemTags != null) {
+      var __FavorItemTags = _o.FavorItemTags.ToArray();
+      _FavorItemTags = CreateFavorItemTagsVector(builder, __FavorItemTags);
+    }
+    var _FavorItemUniqueTags = default(VectorOffset);
+    if (_o.FavorItemUniqueTags != null) {
+      var __FavorItemUniqueTags = _o.FavorItemUniqueTags.ToArray();
+      _FavorItemUniqueTags = CreateFavorItemUniqueTagsVector(builder, __FavorItemUniqueTags);
+    }
+    var _ForbiddenTags = default(VectorOffset);
+    if (_o.ForbiddenTags != null) {
+      var __ForbiddenTags = _o.ForbiddenTags.ToArray();
+      _ForbiddenTags = CreateForbiddenTagsVector(builder, __ForbiddenTags);
+    }
+    var _ZoneWhiteListTags = default(VectorOffset);
+    if (_o.ZoneWhiteListTags != null) {
+      var __ZoneWhiteListTags = _o.ZoneWhiteListTags.ToArray();
+      _ZoneWhiteListTags = CreateZoneWhiteListTagsVector(builder, __ZoneWhiteListTags);
+    }
+    return CreateCharacterAcademyTagsExcel(
+      builder,
+      _o.Id,
+      _FavorTags,
+      _FavorItemTags,
+      _FavorItemUniqueTags,
+      _ForbiddenTags,
+      _ZoneWhiteListTags);
+  }
+}
+
+public class CharacterAcademyTagsExcelT
+{
+  public long Id { get; set; }
+  public List<SCHALE.Common.FlatData.Tag> FavorTags { get; set; }
+  public List<SCHALE.Common.FlatData.Tag> FavorItemTags { get; set; }
+  public List<SCHALE.Common.FlatData.Tag> FavorItemUniqueTags { get; set; }
+  public List<SCHALE.Common.FlatData.Tag> ForbiddenTags { get; set; }
+  public List<SCHALE.Common.FlatData.Tag> ZoneWhiteListTags { get; set; }
+
+  public CharacterAcademyTagsExcelT() {
+    this.Id = 0;
+    this.FavorTags = null;
+    this.FavorItemTags = null;
+    this.FavorItemUniqueTags = null;
+    this.ForbiddenTags = null;
+    this.ZoneWhiteListTags = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CharacterAcademyTagsExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CharacterAcademyTagsExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CharacterAcademyTagsExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterAcademyTagsExcelTable>(o);
   }
+  public CharacterAcademyTagsExcelTableT UnPack() {
+    var _o = new CharacterAcademyTagsExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterAcademyTagsExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterAcademyTagsExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CharacterAcademyTagsExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterAcademyTagsExcelTable> Pack(FlatBufferBuilder builder, CharacterAcademyTagsExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterAcademyTagsExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CharacterAcademyTagsExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CharacterAcademyTagsExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCharacterAcademyTagsExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CharacterAcademyTagsExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CharacterAcademyTagsExcelT> DataList { get; set; }
+
+  public CharacterAcademyTagsExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CharacterCalculationLimitExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CharacterCalculationLimitExcel : IFlatbufferObject
@@ -50,6 +51,46 @@ public struct CharacterCalculationLimitExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterCalculationLimitExcel>(o);
   }
+  public CharacterCalculationLimitExcelT UnPack() {
+    var _o = new CharacterCalculationLimitExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterCalculationLimitExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterCalculationLimit");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.TacticEntityType = TableEncryptionService.Convert(this.TacticEntityType, key);
+    _o.CalculationValue = TableEncryptionService.Convert(this.CalculationValue, key);
+    _o.MinValue = TableEncryptionService.Convert(this.MinValue, key);
+    _o.MaxValue = TableEncryptionService.Convert(this.MaxValue, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterCalculationLimitExcel> Pack(FlatBufferBuilder builder, CharacterCalculationLimitExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterCalculationLimitExcel>);
+    return CreateCharacterCalculationLimitExcel(
+      builder,
+      _o.Id,
+      _o.TacticEntityType,
+      _o.CalculationValue,
+      _o.MinValue,
+      _o.MaxValue);
+  }
+}
+
+public class CharacterCalculationLimitExcelT
+{
+  public long Id { get; set; }
+  public SCHALE.Common.FlatData.TacticEntityType TacticEntityType { get; set; }
+  public SCHALE.Common.FlatData.BattleCalculationStat CalculationValue { get; set; }
+  public long MinValue { get; set; }
+  public long MaxValue { get; set; }
+
+  public CharacterCalculationLimitExcelT() {
+    this.Id = 0;
+    this.TacticEntityType = SCHALE.Common.FlatData.TacticEntityType.None;
+    this.CalculationValue = SCHALE.Common.FlatData.BattleCalculationStat.FinalDamage;
+    this.MinValue = 0;
+    this.MaxValue = 0;
+  }
 }
 
 

SCHALE.Common/FlatData/CharacterCalculationLimitExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CharacterCalculationLimitExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CharacterCalculationLimitExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterCalculationLimitExcelTable>(o);
   }
+  public CharacterCalculationLimitExcelTableT UnPack() {
+    var _o = new CharacterCalculationLimitExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterCalculationLimitExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterCalculationLimitExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CharacterCalculationLimitExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterCalculationLimitExcelTable> Pack(FlatBufferBuilder builder, CharacterCalculationLimitExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterCalculationLimitExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CharacterCalculationLimitExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CharacterCalculationLimitExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCharacterCalculationLimitExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CharacterCalculationLimitExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CharacterCalculationLimitExcelT> DataList { get; set; }
+
+  public CharacterCalculationLimitExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CharacterCombatSkinExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CharacterCombatSkinExcel : IFlatbufferObject
@@ -54,6 +55,40 @@ public struct CharacterCombatSkinExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterCombatSkinExcel>(o);
   }
+  public CharacterCombatSkinExcelT UnPack() {
+    var _o = new CharacterCombatSkinExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterCombatSkinExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterCombatSkin");
+    _o.GroupId = TableEncryptionService.Convert(this.GroupId, key);
+    _o.UniqueId = TableEncryptionService.Convert(this.UniqueId, key);
+    _o.ResourcePath = TableEncryptionService.Convert(this.ResourcePath, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterCombatSkinExcel> Pack(FlatBufferBuilder builder, CharacterCombatSkinExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterCombatSkinExcel>);
+    var _GroupId = _o.GroupId == null ? default(StringOffset) : builder.CreateString(_o.GroupId);
+    var _ResourcePath = _o.ResourcePath == null ? default(StringOffset) : builder.CreateString(_o.ResourcePath);
+    return CreateCharacterCombatSkinExcel(
+      builder,
+      _GroupId,
+      _o.UniqueId,
+      _ResourcePath);
+  }
+}
+
+public class CharacterCombatSkinExcelT
+{
+  public string GroupId { get; set; }
+  public long UniqueId { get; set; }
+  public string ResourcePath { get; set; }
+
+  public CharacterCombatSkinExcelT() {
+    this.GroupId = null;
+    this.UniqueId = 0;
+    this.ResourcePath = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CharacterCombatSkinExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CharacterCombatSkinExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CharacterCombatSkinExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterCombatSkinExcelTable>(o);
   }
+  public CharacterCombatSkinExcelTableT UnPack() {
+    var _o = new CharacterCombatSkinExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterCombatSkinExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterCombatSkinExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CharacterCombatSkinExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterCombatSkinExcelTable> Pack(FlatBufferBuilder builder, CharacterCombatSkinExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterCombatSkinExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CharacterCombatSkinExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CharacterCombatSkinExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCharacterCombatSkinExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CharacterCombatSkinExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CharacterCombatSkinExcelT> DataList { get; set; }
+
+  public CharacterCombatSkinExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CharacterDialogEventExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CharacterDialogEventExcel : IFlatbufferObject
@@ -160,6 +161,125 @@ public struct CharacterDialogEventExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterDialogEventExcel>(o);
   }
+  public CharacterDialogEventExcelT UnPack() {
+    var _o = new CharacterDialogEventExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterDialogEventExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterDialogEvent");
+    _o.CostumeUniqueId = TableEncryptionService.Convert(this.CostumeUniqueId, key);
+    _o.OriginalCharacterId = TableEncryptionService.Convert(this.OriginalCharacterId, key);
+    _o.DisplayOrder = TableEncryptionService.Convert(this.DisplayOrder, key);
+    _o.EventID = TableEncryptionService.Convert(this.EventID, key);
+    _o.ProductionStep = TableEncryptionService.Convert(this.ProductionStep, key);
+    _o.DialogCategory = TableEncryptionService.Convert(this.DialogCategory, key);
+    _o.DialogCondition = TableEncryptionService.Convert(this.DialogCondition, key);
+    _o.DialogConditionDetail = TableEncryptionService.Convert(this.DialogConditionDetail, key);
+    _o.DialogConditionDetailValue = TableEncryptionService.Convert(this.DialogConditionDetailValue, key);
+    _o.GroupId = TableEncryptionService.Convert(this.GroupId, key);
+    _o.DialogType = TableEncryptionService.Convert(this.DialogType, key);
+    _o.ActionName = TableEncryptionService.Convert(this.ActionName, key);
+    _o.Duration = TableEncryptionService.Convert(this.Duration, key);
+    _o.AnimationName = TableEncryptionService.Convert(this.AnimationName, key);
+    _o.LocalizeKR = TableEncryptionService.Convert(this.LocalizeKR, key);
+    _o.LocalizeJP = TableEncryptionService.Convert(this.LocalizeJP, key);
+    _o.VoiceId = new List<uint>();
+    for (var _j = 0; _j < this.VoiceIdLength; ++_j) {_o.VoiceId.Add(TableEncryptionService.Convert(this.VoiceId(_j), key));}
+    _o.CollectionVisible = TableEncryptionService.Convert(this.CollectionVisible, key);
+    _o.CVCollectionType = TableEncryptionService.Convert(this.CVCollectionType, key);
+    _o.UnlockEventSeason = TableEncryptionService.Convert(this.UnlockEventSeason, key);
+    _o.ScenarioGroupId = TableEncryptionService.Convert(this.ScenarioGroupId, key);
+    _o.LocalizeCVGroup = TableEncryptionService.Convert(this.LocalizeCVGroup, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterDialogEventExcel> Pack(FlatBufferBuilder builder, CharacterDialogEventExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterDialogEventExcel>);
+    var _ActionName = _o.ActionName == null ? default(StringOffset) : builder.CreateString(_o.ActionName);
+    var _AnimationName = _o.AnimationName == null ? default(StringOffset) : builder.CreateString(_o.AnimationName);
+    var _LocalizeKR = _o.LocalizeKR == null ? default(StringOffset) : builder.CreateString(_o.LocalizeKR);
+    var _LocalizeJP = _o.LocalizeJP == null ? default(StringOffset) : builder.CreateString(_o.LocalizeJP);
+    var _VoiceId = default(VectorOffset);
+    if (_o.VoiceId != null) {
+      var __VoiceId = _o.VoiceId.ToArray();
+      _VoiceId = CreateVoiceIdVector(builder, __VoiceId);
+    }
+    var _LocalizeCVGroup = _o.LocalizeCVGroup == null ? default(StringOffset) : builder.CreateString(_o.LocalizeCVGroup);
+    return CreateCharacterDialogEventExcel(
+      builder,
+      _o.CostumeUniqueId,
+      _o.OriginalCharacterId,
+      _o.DisplayOrder,
+      _o.EventID,
+      _o.ProductionStep,
+      _o.DialogCategory,
+      _o.DialogCondition,
+      _o.DialogConditionDetail,
+      _o.DialogConditionDetailValue,
+      _o.GroupId,
+      _o.DialogType,
+      _ActionName,
+      _o.Duration,
+      _AnimationName,
+      _LocalizeKR,
+      _LocalizeJP,
+      _VoiceId,
+      _o.CollectionVisible,
+      _o.CVCollectionType,
+      _o.UnlockEventSeason,
+      _o.ScenarioGroupId,
+      _LocalizeCVGroup);
+  }
+}
+
+public class CharacterDialogEventExcelT
+{
+  public long CostumeUniqueId { get; set; }
+  public long OriginalCharacterId { get; set; }
+  public long DisplayOrder { get; set; }
+  public long EventID { get; set; }
+  public SCHALE.Common.FlatData.ProductionStep ProductionStep { get; set; }
+  public SCHALE.Common.FlatData.DialogCategory DialogCategory { get; set; }
+  public SCHALE.Common.FlatData.DialogCondition DialogCondition { get; set; }
+  public SCHALE.Common.FlatData.DialogConditionDetail DialogConditionDetail { get; set; }
+  public long DialogConditionDetailValue { get; set; }
+  public long GroupId { get; set; }
+  public SCHALE.Common.FlatData.DialogType DialogType { get; set; }
+  public string ActionName { get; set; }
+  public long Duration { get; set; }
+  public string AnimationName { get; set; }
+  public string LocalizeKR { get; set; }
+  public string LocalizeJP { get; set; }
+  public List<uint> VoiceId { get; set; }
+  public bool CollectionVisible { get; set; }
+  public SCHALE.Common.FlatData.CVCollectionType CVCollectionType { get; set; }
+  public long UnlockEventSeason { get; set; }
+  public long ScenarioGroupId { get; set; }
+  public string LocalizeCVGroup { get; set; }
+
+  public CharacterDialogEventExcelT() {
+    this.CostumeUniqueId = 0;
+    this.OriginalCharacterId = 0;
+    this.DisplayOrder = 0;
+    this.EventID = 0;
+    this.ProductionStep = SCHALE.Common.FlatData.ProductionStep.ToDo;
+    this.DialogCategory = SCHALE.Common.FlatData.DialogCategory.Cafe;
+    this.DialogCondition = SCHALE.Common.FlatData.DialogCondition.Idle;
+    this.DialogConditionDetail = SCHALE.Common.FlatData.DialogConditionDetail.None;
+    this.DialogConditionDetailValue = 0;
+    this.GroupId = 0;
+    this.DialogType = SCHALE.Common.FlatData.DialogType.Talk;
+    this.ActionName = null;
+    this.Duration = 0;
+    this.AnimationName = null;
+    this.LocalizeKR = null;
+    this.LocalizeJP = null;
+    this.VoiceId = null;
+    this.CollectionVisible = false;
+    this.CVCollectionType = SCHALE.Common.FlatData.CVCollectionType.CVNormal;
+    this.UnlockEventSeason = 0;
+    this.ScenarioGroupId = 0;
+    this.LocalizeCVGroup = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CharacterDialogExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CharacterDialogExcel : IFlatbufferObject
@@ -184,6 +185,139 @@ public struct CharacterDialogExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterDialogExcel>(o);
   }
+  public CharacterDialogExcelT UnPack() {
+    var _o = new CharacterDialogExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterDialogExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterDialog");
+    _o.CharacterId = TableEncryptionService.Convert(this.CharacterId, key);
+    _o.CostumeUniqueId = TableEncryptionService.Convert(this.CostumeUniqueId, key);
+    _o.DisplayOrder = TableEncryptionService.Convert(this.DisplayOrder, key);
+    _o.ProductionStep = TableEncryptionService.Convert(this.ProductionStep, key);
+    _o.DialogCategory = TableEncryptionService.Convert(this.DialogCategory, key);
+    _o.DialogCondition = TableEncryptionService.Convert(this.DialogCondition, key);
+    _o.Anniversary = TableEncryptionService.Convert(this.Anniversary, key);
+    _o.StartDate = TableEncryptionService.Convert(this.StartDate, key);
+    _o.EndDate = TableEncryptionService.Convert(this.EndDate, key);
+    _o.GroupId = TableEncryptionService.Convert(this.GroupId, key);
+    _o.DialogType = TableEncryptionService.Convert(this.DialogType, key);
+    _o.ActionName = TableEncryptionService.Convert(this.ActionName, key);
+    _o.Duration = TableEncryptionService.Convert(this.Duration, key);
+    _o.AnimationName = TableEncryptionService.Convert(this.AnimationName, key);
+    _o.LocalizeKR = TableEncryptionService.Convert(this.LocalizeKR, key);
+    _o.LocalizeJP = TableEncryptionService.Convert(this.LocalizeJP, key);
+    _o.VoiceId = new List<uint>();
+    for (var _j = 0; _j < this.VoiceIdLength; ++_j) {_o.VoiceId.Add(TableEncryptionService.Convert(this.VoiceId(_j), key));}
+    _o.ApplyPosition = TableEncryptionService.Convert(this.ApplyPosition, key);
+    _o.PosX = TableEncryptionService.Convert(this.PosX, key);
+    _o.PosY = TableEncryptionService.Convert(this.PosY, key);
+    _o.CollectionVisible = TableEncryptionService.Convert(this.CollectionVisible, key);
+    _o.CVCollectionType = TableEncryptionService.Convert(this.CVCollectionType, key);
+    _o.UnlockFavorRank = TableEncryptionService.Convert(this.UnlockFavorRank, key);
+    _o.UnlockEquipWeapon = TableEncryptionService.Convert(this.UnlockEquipWeapon, key);
+    _o.LocalizeCVGroup = TableEncryptionService.Convert(this.LocalizeCVGroup, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterDialogExcel> Pack(FlatBufferBuilder builder, CharacterDialogExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterDialogExcel>);
+    var _StartDate = _o.StartDate == null ? default(StringOffset) : builder.CreateString(_o.StartDate);
+    var _EndDate = _o.EndDate == null ? default(StringOffset) : builder.CreateString(_o.EndDate);
+    var _ActionName = _o.ActionName == null ? default(StringOffset) : builder.CreateString(_o.ActionName);
+    var _AnimationName = _o.AnimationName == null ? default(StringOffset) : builder.CreateString(_o.AnimationName);
+    var _LocalizeKR = _o.LocalizeKR == null ? default(StringOffset) : builder.CreateString(_o.LocalizeKR);
+    var _LocalizeJP = _o.LocalizeJP == null ? default(StringOffset) : builder.CreateString(_o.LocalizeJP);
+    var _VoiceId = default(VectorOffset);
+    if (_o.VoiceId != null) {
+      var __VoiceId = _o.VoiceId.ToArray();
+      _VoiceId = CreateVoiceIdVector(builder, __VoiceId);
+    }
+    var _LocalizeCVGroup = _o.LocalizeCVGroup == null ? default(StringOffset) : builder.CreateString(_o.LocalizeCVGroup);
+    return CreateCharacterDialogExcel(
+      builder,
+      _o.CharacterId,
+      _o.CostumeUniqueId,
+      _o.DisplayOrder,
+      _o.ProductionStep,
+      _o.DialogCategory,
+      _o.DialogCondition,
+      _o.Anniversary,
+      _StartDate,
+      _EndDate,
+      _o.GroupId,
+      _o.DialogType,
+      _ActionName,
+      _o.Duration,
+      _AnimationName,
+      _LocalizeKR,
+      _LocalizeJP,
+      _VoiceId,
+      _o.ApplyPosition,
+      _o.PosX,
+      _o.PosY,
+      _o.CollectionVisible,
+      _o.CVCollectionType,
+      _o.UnlockFavorRank,
+      _o.UnlockEquipWeapon,
+      _LocalizeCVGroup);
+  }
+}
+
+public class CharacterDialogExcelT
+{
+  public long CharacterId { get; set; }
+  public long CostumeUniqueId { get; set; }
+  public long DisplayOrder { get; set; }
+  public SCHALE.Common.FlatData.ProductionStep ProductionStep { get; set; }
+  public SCHALE.Common.FlatData.DialogCategory DialogCategory { get; set; }
+  public SCHALE.Common.FlatData.DialogCondition DialogCondition { get; set; }
+  public SCHALE.Common.FlatData.Anniversary Anniversary { get; set; }
+  public string StartDate { get; set; }
+  public string EndDate { get; set; }
+  public long GroupId { get; set; }
+  public SCHALE.Common.FlatData.DialogType DialogType { get; set; }
+  public string ActionName { get; set; }
+  public long Duration { get; set; }
+  public string AnimationName { get; set; }
+  public string LocalizeKR { get; set; }
+  public string LocalizeJP { get; set; }
+  public List<uint> VoiceId { get; set; }
+  public bool ApplyPosition { get; set; }
+  public float PosX { get; set; }
+  public float PosY { get; set; }
+  public bool CollectionVisible { get; set; }
+  public SCHALE.Common.FlatData.CVCollectionType CVCollectionType { get; set; }
+  public long UnlockFavorRank { get; set; }
+  public bool UnlockEquipWeapon { get; set; }
+  public string LocalizeCVGroup { get; set; }
+
+  public CharacterDialogExcelT() {
+    this.CharacterId = 0;
+    this.CostumeUniqueId = 0;
+    this.DisplayOrder = 0;
+    this.ProductionStep = SCHALE.Common.FlatData.ProductionStep.ToDo;
+    this.DialogCategory = SCHALE.Common.FlatData.DialogCategory.Cafe;
+    this.DialogCondition = SCHALE.Common.FlatData.DialogCondition.Idle;
+    this.Anniversary = SCHALE.Common.FlatData.Anniversary.None;
+    this.StartDate = null;
+    this.EndDate = null;
+    this.GroupId = 0;
+    this.DialogType = SCHALE.Common.FlatData.DialogType.Talk;
+    this.ActionName = null;
+    this.Duration = 0;
+    this.AnimationName = null;
+    this.LocalizeKR = null;
+    this.LocalizeJP = null;
+    this.VoiceId = null;
+    this.ApplyPosition = false;
+    this.PosX = 0.0f;
+    this.PosY = 0.0f;
+    this.CollectionVisible = false;
+    this.CVCollectionType = SCHALE.Common.FlatData.CVCollectionType.CVNormal;
+    this.UnlockFavorRank = 0;
+    this.UnlockEquipWeapon = false;
+    this.LocalizeCVGroup = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CharacterDialogFieldExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CharacterDialogFieldExcel : IFlatbufferObject
@@ -88,6 +89,69 @@ public struct CharacterDialogFieldExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterDialogFieldExcel>(o);
   }
+  public CharacterDialogFieldExcelT UnPack() {
+    var _o = new CharacterDialogFieldExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterDialogFieldExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterDialogField");
+    _o.GroupId = TableEncryptionService.Convert(this.GroupId, key);
+    _o.Phase = TableEncryptionService.Convert(this.Phase, key);
+    _o.TargetIndex = TableEncryptionService.Convert(this.TargetIndex, key);
+    _o.DialogType = TableEncryptionService.Convert(this.DialogType, key);
+    _o.Duration = TableEncryptionService.Convert(this.Duration, key);
+    _o.MotionName = TableEncryptionService.Convert(this.MotionName, key);
+    _o.IsInteractionDialog = TableEncryptionService.Convert(this.IsInteractionDialog, key);
+    _o.HideUI = TableEncryptionService.Convert(this.HideUI, key);
+    _o.LocalizeKR = TableEncryptionService.Convert(this.LocalizeKR, key);
+    _o.LocalizeJP = TableEncryptionService.Convert(this.LocalizeJP, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterDialogFieldExcel> Pack(FlatBufferBuilder builder, CharacterDialogFieldExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterDialogFieldExcel>);
+    var _MotionName = _o.MotionName == null ? default(StringOffset) : builder.CreateString(_o.MotionName);
+    var _LocalizeKR = _o.LocalizeKR == null ? default(StringOffset) : builder.CreateString(_o.LocalizeKR);
+    var _LocalizeJP = _o.LocalizeJP == null ? default(StringOffset) : builder.CreateString(_o.LocalizeJP);
+    return CreateCharacterDialogFieldExcel(
+      builder,
+      _o.GroupId,
+      _o.Phase,
+      _o.TargetIndex,
+      _o.DialogType,
+      _o.Duration,
+      _MotionName,
+      _o.IsInteractionDialog,
+      _o.HideUI,
+      _LocalizeKR,
+      _LocalizeJP);
+  }
+}
+
+public class CharacterDialogFieldExcelT
+{
+  public long GroupId { get; set; }
+  public int Phase { get; set; }
+  public int TargetIndex { get; set; }
+  public SCHALE.Common.FlatData.FieldDialogType DialogType { get; set; }
+  public long Duration { get; set; }
+  public string MotionName { get; set; }
+  public bool IsInteractionDialog { get; set; }
+  public bool HideUI { get; set; }
+  public string LocalizeKR { get; set; }
+  public string LocalizeJP { get; set; }
+
+  public CharacterDialogFieldExcelT() {
+    this.GroupId = 0;
+    this.Phase = 0;
+    this.TargetIndex = 0;
+    this.DialogType = SCHALE.Common.FlatData.FieldDialogType.None;
+    this.Duration = 0;
+    this.MotionName = null;
+    this.IsInteractionDialog = false;
+    this.HideUI = false;
+    this.LocalizeKR = null;
+    this.LocalizeJP = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CharacterDialogFieldExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CharacterDialogFieldExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CharacterDialogFieldExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterDialogFieldExcelTable>(o);
   }
+  public CharacterDialogFieldExcelTableT UnPack() {
+    var _o = new CharacterDialogFieldExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterDialogFieldExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterDialogFieldExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CharacterDialogFieldExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterDialogFieldExcelTable> Pack(FlatBufferBuilder builder, CharacterDialogFieldExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterDialogFieldExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CharacterDialogFieldExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CharacterDialogFieldExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCharacterDialogFieldExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CharacterDialogFieldExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CharacterDialogFieldExcelT> DataList { get; set; }
+
+  public CharacterDialogFieldExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CharacterExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CharacterExcel : IFlatbufferObject
@@ -332,6 +333,291 @@ public struct CharacterExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterExcel>(o);
   }
+  public CharacterExcelT UnPack() {
+    var _o = new CharacterExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("Character");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.DevName = TableEncryptionService.Convert(this.DevName, key);
+    _o.CostumeGroupId = TableEncryptionService.Convert(this.CostumeGroupId, key);
+    _o.IsPlayable = TableEncryptionService.Convert(this.IsPlayable, key);
+    _o.ProductionStep = TableEncryptionService.Convert(this.ProductionStep, key);
+    _o.CollectionVisible = TableEncryptionService.Convert(this.CollectionVisible, key);
+    _o.ReleaseDate = TableEncryptionService.Convert(this.ReleaseDate, key);
+    _o.CollectionVisibleStartDate = TableEncryptionService.Convert(this.CollectionVisibleStartDate, key);
+    _o.CollectionVisibleEndDate = TableEncryptionService.Convert(this.CollectionVisibleEndDate, key);
+    _o.IsPlayableCharacter = TableEncryptionService.Convert(this.IsPlayableCharacter, key);
+    _o.LocalizeEtcId = TableEncryptionService.Convert(this.LocalizeEtcId, key);
+    _o.Rarity = TableEncryptionService.Convert(this.Rarity, key);
+    _o.IsNPC = TableEncryptionService.Convert(this.IsNPC, key);
+    _o.TacticEntityType = TableEncryptionService.Convert(this.TacticEntityType, key);
+    _o.CanSurvive = TableEncryptionService.Convert(this.CanSurvive, key);
+    _o.IsDummy = TableEncryptionService.Convert(this.IsDummy, key);
+    _o.SubPartsCount = TableEncryptionService.Convert(this.SubPartsCount, key);
+    _o.TacticRole = TableEncryptionService.Convert(this.TacticRole, key);
+    _o.WeaponType = TableEncryptionService.Convert(this.WeaponType, key);
+    _o.TacticRange = TableEncryptionService.Convert(this.TacticRange, key);
+    _o.BulletType = TableEncryptionService.Convert(this.BulletType, key);
+    _o.ArmorType = TableEncryptionService.Convert(this.ArmorType, key);
+    _o.AimIKType = TableEncryptionService.Convert(this.AimIKType, key);
+    _o.School = TableEncryptionService.Convert(this.School, key);
+    _o.Club = TableEncryptionService.Convert(this.Club, key);
+    _o.DefaultStarGrade = TableEncryptionService.Convert(this.DefaultStarGrade, key);
+    _o.MaxStarGrade = TableEncryptionService.Convert(this.MaxStarGrade, key);
+    _o.StatLevelUpType = TableEncryptionService.Convert(this.StatLevelUpType, key);
+    _o.SquadType = TableEncryptionService.Convert(this.SquadType, key);
+    _o.Jumpable = TableEncryptionService.Convert(this.Jumpable, key);
+    _o.PersonalityId = TableEncryptionService.Convert(this.PersonalityId, key);
+    _o.CharacterAIId = TableEncryptionService.Convert(this.CharacterAIId, key);
+    _o.ExternalBTId = TableEncryptionService.Convert(this.ExternalBTId, key);
+    _o.ScenarioCharacter = TableEncryptionService.Convert(this.ScenarioCharacter, key);
+    _o.SpawnTemplateId = TableEncryptionService.Convert(this.SpawnTemplateId, key);
+    _o.FavorLevelupType = TableEncryptionService.Convert(this.FavorLevelupType, key);
+    _o.EquipmentSlot = new List<SCHALE.Common.FlatData.EquipmentCategory>();
+    for (var _j = 0; _j < this.EquipmentSlotLength; ++_j) {_o.EquipmentSlot.Add(TableEncryptionService.Convert(this.EquipmentSlot(_j), key));}
+    _o.WeaponLocalizeId = TableEncryptionService.Convert(this.WeaponLocalizeId, key);
+    _o.DisplayEnemyInfo = TableEncryptionService.Convert(this.DisplayEnemyInfo, key);
+    _o.BodyRadius = TableEncryptionService.Convert(this.BodyRadius, key);
+    _o.RandomEffectRadius = TableEncryptionService.Convert(this.RandomEffectRadius, key);
+    _o.HPBarHide = TableEncryptionService.Convert(this.HPBarHide, key);
+    _o.HpBarHeight = TableEncryptionService.Convert(this.HpBarHeight, key);
+    _o.HighlightFloaterHeight = TableEncryptionService.Convert(this.HighlightFloaterHeight, key);
+    _o.EmojiOffsetX = TableEncryptionService.Convert(this.EmojiOffsetX, key);
+    _o.EmojiOffsetY = TableEncryptionService.Convert(this.EmojiOffsetY, key);
+    _o.MoveStartFrame = TableEncryptionService.Convert(this.MoveStartFrame, key);
+    _o.MoveEndFrame = TableEncryptionService.Convert(this.MoveEndFrame, key);
+    _o.JumpMotionFrame = TableEncryptionService.Convert(this.JumpMotionFrame, key);
+    _o.AppearFrame = TableEncryptionService.Convert(this.AppearFrame, key);
+    _o.CanMove = TableEncryptionService.Convert(this.CanMove, key);
+    _o.CanFix = TableEncryptionService.Convert(this.CanFix, key);
+    _o.CanCrowdControl = TableEncryptionService.Convert(this.CanCrowdControl, key);
+    _o.CanBattleItemMove = TableEncryptionService.Convert(this.CanBattleItemMove, key);
+    _o.IsAirUnit = TableEncryptionService.Convert(this.IsAirUnit, key);
+    _o.AirUnitHeight = TableEncryptionService.Convert(this.AirUnitHeight, key);
+    _o.Tags = new List<SCHALE.Common.FlatData.Tag>();
+    for (var _j = 0; _j < this.TagsLength; ++_j) {_o.Tags.Add(TableEncryptionService.Convert(this.Tags(_j), key));}
+    _o.SecretStoneItemId = TableEncryptionService.Convert(this.SecretStoneItemId, key);
+    _o.SecretStoneItemAmount = TableEncryptionService.Convert(this.SecretStoneItemAmount, key);
+    _o.CharacterPieceItemId = TableEncryptionService.Convert(this.CharacterPieceItemId, key);
+    _o.CharacterPieceItemAmount = TableEncryptionService.Convert(this.CharacterPieceItemAmount, key);
+    _o.CombineRecipeId = TableEncryptionService.Convert(this.CombineRecipeId, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterExcel> Pack(FlatBufferBuilder builder, CharacterExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterExcel>);
+    var _DevName = _o.DevName == null ? default(StringOffset) : builder.CreateString(_o.DevName);
+    var _ReleaseDate = _o.ReleaseDate == null ? default(StringOffset) : builder.CreateString(_o.ReleaseDate);
+    var _CollectionVisibleStartDate = _o.CollectionVisibleStartDate == null ? default(StringOffset) : builder.CreateString(_o.CollectionVisibleStartDate);
+    var _CollectionVisibleEndDate = _o.CollectionVisibleEndDate == null ? default(StringOffset) : builder.CreateString(_o.CollectionVisibleEndDate);
+    var _ScenarioCharacter = _o.ScenarioCharacter == null ? default(StringOffset) : builder.CreateString(_o.ScenarioCharacter);
+    var _EquipmentSlot = default(VectorOffset);
+    if (_o.EquipmentSlot != null) {
+      var __EquipmentSlot = _o.EquipmentSlot.ToArray();
+      _EquipmentSlot = CreateEquipmentSlotVector(builder, __EquipmentSlot);
+    }
+    var _Tags = default(VectorOffset);
+    if (_o.Tags != null) {
+      var __Tags = _o.Tags.ToArray();
+      _Tags = CreateTagsVector(builder, __Tags);
+    }
+    return CreateCharacterExcel(
+      builder,
+      _o.Id,
+      _DevName,
+      _o.CostumeGroupId,
+      _o.IsPlayable,
+      _o.ProductionStep,
+      _o.CollectionVisible,
+      _ReleaseDate,
+      _CollectionVisibleStartDate,
+      _CollectionVisibleEndDate,
+      _o.IsPlayableCharacter,
+      _o.LocalizeEtcId,
+      _o.Rarity,
+      _o.IsNPC,
+      _o.TacticEntityType,
+      _o.CanSurvive,
+      _o.IsDummy,
+      _o.SubPartsCount,
+      _o.TacticRole,
+      _o.WeaponType,
+      _o.TacticRange,
+      _o.BulletType,
+      _o.ArmorType,
+      _o.AimIKType,
+      _o.School,
+      _o.Club,
+      _o.DefaultStarGrade,
+      _o.MaxStarGrade,
+      _o.StatLevelUpType,
+      _o.SquadType,
+      _o.Jumpable,
+      _o.PersonalityId,
+      _o.CharacterAIId,
+      _o.ExternalBTId,
+      _ScenarioCharacter,
+      _o.SpawnTemplateId,
+      _o.FavorLevelupType,
+      _EquipmentSlot,
+      _o.WeaponLocalizeId,
+      _o.DisplayEnemyInfo,
+      _o.BodyRadius,
+      _o.RandomEffectRadius,
+      _o.HPBarHide,
+      _o.HpBarHeight,
+      _o.HighlightFloaterHeight,
+      _o.EmojiOffsetX,
+      _o.EmojiOffsetY,
+      _o.MoveStartFrame,
+      _o.MoveEndFrame,
+      _o.JumpMotionFrame,
+      _o.AppearFrame,
+      _o.CanMove,
+      _o.CanFix,
+      _o.CanCrowdControl,
+      _o.CanBattleItemMove,
+      _o.IsAirUnit,
+      _o.AirUnitHeight,
+      _Tags,
+      _o.SecretStoneItemId,
+      _o.SecretStoneItemAmount,
+      _o.CharacterPieceItemId,
+      _o.CharacterPieceItemAmount,
+      _o.CombineRecipeId);
+  }
+}
+
+public class CharacterExcelT
+{
+  public long Id { get; set; }
+  public string DevName { get; set; }
+  public long CostumeGroupId { get; set; }
+  public bool IsPlayable { get; set; }
+  public SCHALE.Common.FlatData.ProductionStep ProductionStep { get; set; }
+  public bool CollectionVisible { get; set; }
+  public string ReleaseDate { get; set; }
+  public string CollectionVisibleStartDate { get; set; }
+  public string CollectionVisibleEndDate { get; set; }
+  public bool IsPlayableCharacter { get; set; }
+  public uint LocalizeEtcId { get; set; }
+  public SCHALE.Common.FlatData.Rarity Rarity { get; set; }
+  public bool IsNPC { get; set; }
+  public SCHALE.Common.FlatData.TacticEntityType TacticEntityType { get; set; }
+  public bool CanSurvive { get; set; }
+  public bool IsDummy { get; set; }
+  public int SubPartsCount { get; set; }
+  public SCHALE.Common.FlatData.TacticRole TacticRole { get; set; }
+  public SCHALE.Common.FlatData.WeaponType WeaponType { get; set; }
+  public SCHALE.Common.FlatData.TacticRange TacticRange { get; set; }
+  public SCHALE.Common.FlatData.BulletType BulletType { get; set; }
+  public SCHALE.Common.FlatData.ArmorType ArmorType { get; set; }
+  public SCHALE.Common.FlatData.AimIKType AimIKType { get; set; }
+  public SCHALE.Common.FlatData.School School { get; set; }
+  public SCHALE.Common.FlatData.Club Club { get; set; }
+  public int DefaultStarGrade { get; set; }
+  public int MaxStarGrade { get; set; }
+  public SCHALE.Common.FlatData.StatLevelUpType StatLevelUpType { get; set; }
+  public SCHALE.Common.FlatData.SquadType SquadType { get; set; }
+  public bool Jumpable { get; set; }
+  public long PersonalityId { get; set; }
+  public long CharacterAIId { get; set; }
+  public long ExternalBTId { get; set; }
+  public string ScenarioCharacter { get; set; }
+  public uint SpawnTemplateId { get; set; }
+  public int FavorLevelupType { get; set; }
+  public List<SCHALE.Common.FlatData.EquipmentCategory> EquipmentSlot { get; set; }
+  public uint WeaponLocalizeId { get; set; }
+  public bool DisplayEnemyInfo { get; set; }
+  public long BodyRadius { get; set; }
+  public long RandomEffectRadius { get; set; }
+  public bool HPBarHide { get; set; }
+  public float HpBarHeight { get; set; }
+  public float HighlightFloaterHeight { get; set; }
+  public float EmojiOffsetX { get; set; }
+  public float EmojiOffsetY { get; set; }
+  public int MoveStartFrame { get; set; }
+  public int MoveEndFrame { get; set; }
+  public int JumpMotionFrame { get; set; }
+  public int AppearFrame { get; set; }
+  public bool CanMove { get; set; }
+  public bool CanFix { get; set; }
+  public bool CanCrowdControl { get; set; }
+  public bool CanBattleItemMove { get; set; }
+  public bool IsAirUnit { get; set; }
+  public long AirUnitHeight { get; set; }
+  public List<SCHALE.Common.FlatData.Tag> Tags { get; set; }
+  public long SecretStoneItemId { get; set; }
+  public int SecretStoneItemAmount { get; set; }
+  public long CharacterPieceItemId { get; set; }
+  public int CharacterPieceItemAmount { get; set; }
+  public long CombineRecipeId { get; set; }
+
+  public CharacterExcelT() {
+    this.Id = 0;
+    this.DevName = null;
+    this.CostumeGroupId = 0;
+    this.IsPlayable = false;
+    this.ProductionStep = SCHALE.Common.FlatData.ProductionStep.ToDo;
+    this.CollectionVisible = false;
+    this.ReleaseDate = null;
+    this.CollectionVisibleStartDate = null;
+    this.CollectionVisibleEndDate = null;
+    this.IsPlayableCharacter = false;
+    this.LocalizeEtcId = 0;
+    this.Rarity = SCHALE.Common.FlatData.Rarity.N;
+    this.IsNPC = false;
+    this.TacticEntityType = SCHALE.Common.FlatData.TacticEntityType.None;
+    this.CanSurvive = false;
+    this.IsDummy = false;
+    this.SubPartsCount = 0;
+    this.TacticRole = SCHALE.Common.FlatData.TacticRole.None;
+    this.WeaponType = SCHALE.Common.FlatData.WeaponType.None;
+    this.TacticRange = SCHALE.Common.FlatData.TacticRange.Back;
+    this.BulletType = SCHALE.Common.FlatData.BulletType.Normal;
+    this.ArmorType = SCHALE.Common.FlatData.ArmorType.LightArmor;
+    this.AimIKType = SCHALE.Common.FlatData.AimIKType.None;
+    this.School = SCHALE.Common.FlatData.School.None;
+    this.Club = SCHALE.Common.FlatData.Club.None;
+    this.DefaultStarGrade = 0;
+    this.MaxStarGrade = 0;
+    this.StatLevelUpType = SCHALE.Common.FlatData.StatLevelUpType.Standard;
+    this.SquadType = SCHALE.Common.FlatData.SquadType.None;
+    this.Jumpable = false;
+    this.PersonalityId = 0;
+    this.CharacterAIId = 0;
+    this.ExternalBTId = 0;
+    this.ScenarioCharacter = null;
+    this.SpawnTemplateId = 0;
+    this.FavorLevelupType = 0;
+    this.EquipmentSlot = null;
+    this.WeaponLocalizeId = 0;
+    this.DisplayEnemyInfo = false;
+    this.BodyRadius = 0;
+    this.RandomEffectRadius = 0;
+    this.HPBarHide = false;
+    this.HpBarHeight = 0.0f;
+    this.HighlightFloaterHeight = 0.0f;
+    this.EmojiOffsetX = 0.0f;
+    this.EmojiOffsetY = 0.0f;
+    this.MoveStartFrame = 0;
+    this.MoveEndFrame = 0;
+    this.JumpMotionFrame = 0;
+    this.AppearFrame = 0;
+    this.CanMove = false;
+    this.CanFix = false;
+    this.CanCrowdControl = false;
+    this.CanBattleItemMove = false;
+    this.IsAirUnit = false;
+    this.AirUnitHeight = 0;
+    this.Tags = null;
+    this.SecretStoneItemId = 0;
+    this.SecretStoneItemAmount = 0;
+    this.CharacterPieceItemId = 0;
+    this.CharacterPieceItemAmount = 0;
+    this.CombineRecipeId = 0;
+  }
 }
 
 

SCHALE.Common/FlatData/CharacterExcelTable.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CharacterExcelTable : IFlatbufferObject
@@ -40,6 +41,37 @@ public struct CharacterExcelTable : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterExcelTable>(o);
   }
+  public CharacterExcelTableT UnPack() {
+    var _o = new CharacterExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CharacterExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterExcelTable> Pack(FlatBufferBuilder builder, CharacterExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CharacterExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CharacterExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCharacterExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CharacterExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CharacterExcelT> DataList { get; set; }
+
+  public CharacterExcelTableT() {
+    this.DataList = null;
+  }
 }
 
 

SCHALE.Common/FlatData/CharacterGearExcel.cs

@@ -7,6 +7,7 @@ namespace SCHALE.Common.FlatData
 
 using global::System;
 using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
 using global::Google.FlatBuffers;
 
 public struct CharacterGearExcel : IFlatbufferObject
@@ -150,6 +151,112 @@ public struct CharacterGearExcel : IFlatbufferObject
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterGearExcel>(o);
   }
+  public CharacterGearExcelT UnPack() {
+    var _o = new CharacterGearExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterGearExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterGear");
+    _o.Id = TableEncryptionService.Convert(this.Id, key);
+    _o.CharacterId = TableEncryptionService.Convert(this.CharacterId, key);
+    _o.StatLevelUpType = TableEncryptionService.Convert(this.StatLevelUpType, key);
+    _o.Tier = TableEncryptionService.Convert(this.Tier, key);
+    _o.NextTierEquipment = TableEncryptionService.Convert(this.NextTierEquipment, key);
+    _o.RecipeId = TableEncryptionService.Convert(this.RecipeId, key);
+    _o.OpenFavorLevel = TableEncryptionService.Convert(this.OpenFavorLevel, key);
+    _o.MaxLevel = TableEncryptionService.Convert(this.MaxLevel, key);
+    _o.LearnSkillSlot = TableEncryptionService.Convert(this.LearnSkillSlot, key);
+    _o.StatType = new List<SCHALE.Common.FlatData.EquipmentOptionType>();
+    for (var _j = 0; _j < this.StatTypeLength; ++_j) {_o.StatType.Add(TableEncryptionService.Convert(this.StatType(_j), key));}
+    _o.MinStatValue = new List<long>();
+    for (var _j = 0; _j < this.MinStatValueLength; ++_j) {_o.MinStatValue.Add(TableEncryptionService.Convert(this.MinStatValue(_j), key));}
+    _o.MaxStatValue = new List<long>();
+    for (var _j = 0; _j < this.MaxStatValueLength; ++_j) {_o.MaxStatValue.Add(TableEncryptionService.Convert(this.MaxStatValue(_j), key));}
+    _o.Icon = TableEncryptionService.Convert(this.Icon, key);
+    _o.LocalizeEtcId = TableEncryptionService.Convert(this.LocalizeEtcId, key);
+    _o.Tags = new List<SCHALE.Common.FlatData.Tag>();
+    for (var _j = 0; _j < this.TagsLength; ++_j) {_o.Tags.Add(TableEncryptionService.Convert(this.Tags(_j), key));}
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterGearExcel> Pack(FlatBufferBuilder builder, CharacterGearExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterGearExcel>);
+    var _LearnSkillSlot = _o.LearnSkillSlot == null ? default(StringOffset) : builder.CreateString(_o.LearnSkillSlot);
+    var _StatType = default(VectorOffset);
+    if (_o.StatType != null) {
+      var __StatType = _o.StatType.ToArray();
+      _StatType = CreateStatTypeVector(builder, __StatType);
+    }
+    var _MinStatValue = default(VectorOffset);
+    if (_o.MinStatValue != null) {
+      var __MinStatValue = _o.MinStatValue.ToArray();
+      _MinStatValue = CreateMinStatValueVector(builder, __MinStatValue);
+    }
+    var _MaxStatValue = default(VectorOffset);
+    if (_o.MaxStatValue != null) {
+      var __MaxStatValue = _o.MaxStatValue.ToArray();
+      _MaxStatValue = CreateMaxStatValueVector(builder, __MaxStatValue);
+    }
+    var _Icon = _o.Icon == null ? default(StringOffset) : builder.CreateString(_o.Icon);
+    var _Tags = default(VectorOffset);
+    if (_o.Tags != null) {
+      var __Tags = _o.Tags.ToArray();
+      _Tags = CreateTagsVector(builder, __Tags);
+    }
+    return CreateCharacterGearExcel(
+      builder,
+      _o.Id,
+      _o.CharacterId,
+      _o.StatLevelUpType,
+      _o.Tier,
+      _o.NextTierEquipment,
+      _o.RecipeId,
+      _o.OpenFavorLevel,
+      _o.MaxLevel,
+      _LearnSkillSlot,
+      _StatType,
+      _MinStatValue,
+      _MaxStatValue,
+      _Icon,
+      _o.LocalizeEtcId,
+      _Tags);
+  }
+}
+
+public class CharacterGearExcelT
+{
+  public long Id { get; set; }
+  public long CharacterId { get; set; }
+  public SCHALE.Common.FlatData.StatLevelUpType StatLevelUpType { get; set; }
+  public long Tier { get; set; }
+  public long NextTierEquipment { get; set; }
+  public long RecipeId { get; set; }
+  public long OpenFavorLevel { get; set; }
+  public long MaxLevel { get; set; }
+  public string LearnSkillSlot { get; set; }
+  public List<SCHALE.Common.FlatData.EquipmentOptionType> StatType { get; set; }
+  public List<long> MinStatValue { get; set; }
+  public List<long> MaxStatValue { get; set; }
+  public string Icon { get; set; }
+  public uint LocalizeEtcId { get; set; }
+  public List<SCHALE.Common.FlatData.Tag> Tags { get; set; }
+
+  public CharacterGearExcelT() {
+    this.Id = 0;
+    this.CharacterId = 0;
+    this.StatLevelUpType = SCHALE.Common.FlatData.StatLevelUpType.Standard;
+    this.Tier = 0;
+    this.NextTierEquipment = 0;
+    this.RecipeId = 0;
+    this.OpenFavorLevel = 0;
+    this.MaxLevel = 0;
+    this.LearnSkillSlot = null;
+    this.StatType = null;
+    this.MinStatValue = null;
+    this.MaxStatValue = null;
+    this.Icon = null;
+    this.LocalizeEtcId = 0;
+    this.Tags = null;
+  }
 }