flats and get protocol just from json

SCHALE.Common/Crypto/TableEncryptionService.cs

@@ -0,0 +1,39 @@
+using MersenneTwister;
+using SCHALE.Common.Crypto.XXHash;
+using System.Buffers.Binary;
+using System.Text;
+
+namespace SCHALE.Common.Crypto
+{
+    public static class TableEncryptionService
+    {
+        /// <summary>
+        /// Used for decrypting .bytes flatbuffers bin. Doesn't work yet
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="bytes"></param>
+        public static void XOR(string name, byte[] bytes)
+        {
+            using var xxhash = XXHash32.Create();
+            xxhash.ComputeHash(Encoding.UTF8.GetBytes(name));
+
+            var mt = MTRandom.Create((int)xxhash.HashUInt32);
+            var key = GC.AllocateUninitializedArray<byte>(sizeof(int));
+            BinaryPrimitives.WriteInt32LittleEndian(key, mt.Next() + 1);
+
+            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++];
+            }
+        }
+    }
+}

SCHALE.Common/Crypto/TableService.cs

@@ -0,0 +1,35 @@
+using MersenneTwister;
+using SCHALE.Common.Crypto.XXHash;
+using System.Text;
+
+namespace SCHALE.Common.Crypto
+{
+    public static class TableService
+    {
+        /// <summary>
+        /// General password gen by file name, encode to base64 for zips password
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="length"></param>
+        /// <returns></returns>
+        public static byte[] CreatePassword(string key, int length = 20)
+        {
+            byte[] password = GC.AllocateUninitializedArray<byte>((int)Math.Round((decimal)(length / 4 * 3)));
+
+            using var xxhash = XXHash32.Create();
+            xxhash.ComputeHash(Encoding.UTF8.GetBytes(key));
+
+            var mt = MTRandom.Create((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() + 1), 0, password, i, Math.Min(4, password.Length - i));
+                i += 4;
+            }
+
+            return password;
+        }
+    }
+}

SCHALE.Common/Crypto/XOR.cs

@@ -2,11 +2,12 @@
 {
     public static class XOR
     {
-        public static void Crypt(byte[] bytes, byte key, uint offset = 0)
+        public static void Crypt(byte[] bytes, byte[] key, uint offset = 0)
         {
             while (offset < bytes.Length)
             {
-                bytes[offset++] ^= key;
+                bytes[offset] ^= key[offset % key.Length];
+                offset++;
             }
         }
     }

SCHALE.Common/Crypto/XXHash.cs

@@ -0,0 +1,590 @@
+/*MIT License
+
+Copyright (c) 2018 differentrain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. */
+
+/*
+ * The minimum requirements for YYProject.XXHash are .NET Framework 3.5, and C# 7.0 ,
+ * it means that these code also apply to .NET Core 1.0 or later, Mono 4.6 or later and so on.
+ * If necessary, you can also rewrite these library to .NET Framework 2.0 with just a little work. 
+ * Since all code (XXHash32 and XXHash64) are inside these file independently, 
+ * I don't recommend using compiled library in your project.
+ * Instead, you can just copy the useful parts to your code, this is the benefit of MIT License. P:)
+ * 
+ * If you are using .NET4.5 (or higher) or sibling frameworks,  you can add conditional compilation
+ * symbol "HIGHER_VERSIONS" to optimize static-short-methods.
+ */
+
+#define HIGHER_VERSIONS
+
+using System.Security.Cryptography;
+#if HIGHER_VERSIONS
+using System.Runtime.CompilerServices;
+#endif
+
+
+namespace SCHALE.Common.Crypto.XXHash
+{
+    //see details: https://github.com/Cyan4973/xxHash/blob/dev/doc/xxhash_spec.md
+
+    /// <summary>
+    /// Represents the class which provides a implementation of the xxHash32 algorithm.
+    /// </summary>
+    ///<threadsafety static="true" instance="false"/>   
+    public sealed class XXHash32 : HashAlgorithm
+    {
+        private const uint PRIME32_1 = 2654435761U;
+        private const uint PRIME32_2 = 2246822519U;
+        private const uint PRIME32_3 = 3266489917U;
+        private const uint PRIME32_4 = 668265263U;
+        private const uint PRIME32_5 = 374761393U;
+
+        private static readonly Func<byte[], int, uint> FuncGetLittleEndianUInt32;
+        private static readonly Func<uint, uint> FuncGetFinalHashUInt32;
+
+        private uint _Seed32;
+
+        private uint _ACC32_1;
+        private uint _ACC32_2;
+        private uint _ACC32_3;
+        private uint _ACC32_4;
+
+        private uint _Hash32;
+
+
+        private int _RemainingLength;
+        private long _TotalLength = 0;
+        private int _CurrentIndex;
+        private byte[] _CurrentArray;
+
+        static XXHash32()
+        {
+            if (BitConverter.IsLittleEndian)
+            {
+
+                FuncGetLittleEndianUInt32 = new Func<byte[], int, uint>((x, i) =>
+                {
+                    unsafe
+                    {
+                        fixed (byte* array = x)
+                        {
+                            return *(uint*)(array + i);
+                        }
+                    }
+                });
+                FuncGetFinalHashUInt32 = new Func<uint, uint>(i => (i & 0x000000FFU) << 24 | (i & 0x0000FF00U) << 8 | (i & 0x00FF0000U) >> 8 | (i & 0xFF000000U) >> 24);
+            }
+            else
+            {
+                FuncGetLittleEndianUInt32 = new Func<byte[], int, uint>((x, i) =>
+                {
+                    unsafe
+                    {
+                        fixed (byte* array = x)
+                        {
+                            return (uint)(array[i++] | (array[i++] << 8) | (array[i++] << 16) | (array[i] << 24));
+                        }
+                    }
+                });
+                FuncGetFinalHashUInt32 = new Func<uint, uint>(i => i);
+            }
+        }
+
+        /// <summary>
+        /// Creates an instance of <see cref="XXHash32"/> class by default seed(0).
+        /// </summary>
+        /// <returns></returns>
+        public new static XXHash32 Create() => new XXHash32();
+
+        /// <summary>
+        /// Creates an instance of the specified implementation of XXHash32 algorithm.
+        /// <para>This method always throws <see cref="NotSupportedException"/>. </para>
+        /// </summary>
+        /// <param name="algName">The hash algorithm implementation to use.</param>
+        /// <returns>This method always throws <see cref="NotSupportedException"/>. </returns>
+        /// <exception cref="NotSupportedException">This method is not be supported.</exception>
+        public new static XXHash32 Create(string algName) => throw new NotSupportedException("This method is not be supported.");
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="XXHash32"/> class by default seed(0).
+        /// </summary>
+        public XXHash32() => Initialize(0);
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="XXHash32"/> class, and sets the <see cref="Seed"/> to the specified value.
+        /// </summary>
+        /// <param name="seed">Represent the seed to be used for xxHash32 computing.</param>
+        public XXHash32(uint seed) => Initialize(seed);
+
+        /// <summary>
+        /// Gets the <see cref="uint"/> value of the computed hash code.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">Hash computation has not yet completed.</exception>
+        public uint HashUInt32 => State == 0 ? _Hash32 : throw new InvalidOperationException("Hash computation has not yet completed.");
+
+        /// <summary>
+        /// Gets or sets the value of seed used by xxHash32 algorithm.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">Hash computation has not yet completed.</exception>
+        public uint Seed
+        {
+            get => _Seed32;
+            set
+            {
+
+                if (value != _Seed32)
+                {
+                    if (State != 0) throw new InvalidOperationException("Hash computation has not yet completed.");
+                    _Seed32 = value;
+                    Initialize();
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Initializes this instance for new hash computing.
+        /// </summary>
+        public override void Initialize()
+        {
+            _ACC32_1 = _Seed32 + PRIME32_1 + PRIME32_2;
+            _ACC32_2 = _Seed32 + PRIME32_2;
+            _ACC32_3 = _Seed32 + 0;
+            _ACC32_4 = _Seed32 - PRIME32_1;
+        }
+
+
+
+        /// <summary>
+        /// Routes data written to the object into the hash algorithm for computing the hash.
+        /// </summary>
+        /// <param name="array">The input to compute the hash code for.</param>
+        /// <param name="ibStart">The offset into the byte array from which to begin using data.</param>
+        /// <param name="cbSize">The number of bytes in the byte array to use as data.</param>
+        protected override void HashCore(byte[] array, int ibStart, int cbSize)
+        {
+            if (State != 1) State = 1;
+            var size = cbSize - ibStart;
+            _RemainingLength = size & 15;
+            if (cbSize >= 16)
+            {
+                var limit = size - _RemainingLength;
+                do
+                {
+                    _ACC32_1 = Round32(_ACC32_1, FuncGetLittleEndianUInt32(array, ibStart));
+                    ibStart += 4;
+                    _ACC32_2 = Round32(_ACC32_2, FuncGetLittleEndianUInt32(array, ibStart));
+                    ibStart += 4;
+                    _ACC32_3 = Round32(_ACC32_3, FuncGetLittleEndianUInt32(array, ibStart));
+                    ibStart += 4;
+                    _ACC32_4 = Round32(_ACC32_4, FuncGetLittleEndianUInt32(array, ibStart));
+                    ibStart += 4;
+                } while (ibStart < limit);
+            }
+            _TotalLength += cbSize;
+
+            if (_RemainingLength != 0)
+            {
+                _CurrentArray = array;
+                _CurrentIndex = ibStart;
+            }
+        }
+
+        /// <summary>
+        /// Finalizes the hash computation after the last data is processed by the cryptographic stream object.
+        /// </summary>
+        /// <returns>The computed hash code.</returns>
+        protected override byte[] HashFinal()
+        {
+            if (_TotalLength >= 16)
+            {
+#if HIGHER_VERSIONS
+                _Hash32 = RotateLeft32_1(_ACC32_1) + RotateLeft32_7(_ACC32_2) + RotateLeft32_12(_ACC32_3) + RotateLeft32_18(_ACC32_4);
+#else
+                _Hash32 = RotateLeft32(_ACC32_1, 1) + RotateLeft32(_ACC32_2, 7) + RotateLeft32(_ACC32_3, 12) + RotateLeft32(_ACC32_4, 18);
+#endif
+            }
+            else
+            {
+                _Hash32 = _Seed32 + PRIME32_5;
+            }
+
+            _Hash32 += (uint)_TotalLength;
+
+            while (_RemainingLength >= 4)
+            {
+#if HIGHER_VERSIONS
+                _Hash32 = RotateLeft32_17(_Hash32 + FuncGetLittleEndianUInt32(_CurrentArray, _CurrentIndex) * PRIME32_3) * PRIME32_4;
+#else
+                _Hash32 = RotateLeft32(_Hash32 + FuncGetLittleEndianUInt32(_CurrentArray, _CurrentIndex) * PRIME32_3, 17) * PRIME32_4;
+#endif
+                _CurrentIndex += 4;
+                _RemainingLength -= 4;
+            }
+            unsafe
+            {
+                fixed (byte* arrayPtr = _CurrentArray)
+                {
+                    while (_RemainingLength-- >= 1)
+                    {
+#if HIGHER_VERSIONS
+                        _Hash32 = RotateLeft32_11(_Hash32 + arrayPtr[_CurrentIndex++] * PRIME32_5) * PRIME32_1;
+#else
+                        _Hash32 = RotateLeft32(_Hash32 + arrayPtr[_CurrentIndex++] * PRIME32_5, 11) * PRIME32_1;
+#endif
+                    }
+                }
+            }
+            _Hash32 = (_Hash32 ^ (_Hash32 >> 15)) * PRIME32_2;
+            _Hash32 = (_Hash32 ^ (_Hash32 >> 13)) * PRIME32_3;
+            _Hash32 ^= _Hash32 >> 16;
+
+            _TotalLength = State = 0;
+
+            return BitConverter.GetBytes(FuncGetFinalHashUInt32(_Hash32));
+        }
+
+#if HIGHER_VERSIONS
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static uint Round32(uint input, uint value) => RotateLeft32_13(input + (value * PRIME32_2)) * PRIME32_1;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static uint RotateLeft32_1(uint value) => (value << 1) | (value >> 31); //_ACC32_1
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static uint RotateLeft32_7(uint value) => (value << 7) | (value >> 25); //_ACC32_2
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static uint RotateLeft32_11(uint value) => (value << 11) | (value >> 21);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static uint RotateLeft32_12(uint value) => (value << 12) | (value >> 20);// _ACC32_3
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static uint RotateLeft32_13(uint value) => (value << 13) | (value >> 19);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static uint RotateLeft32_17(uint value) => (value << 17) | (value >> 15);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static uint RotateLeft32_18(uint value) => (value << 18) | (value >> 14); //_ACC32_4
+#else
+        private static uint Round32(uint input, uint value) => RotateLeft32(input + (value * PRIME32_2), 13) * PRIME32_1;
+
+        private static uint RotateLeft32(uint value, int count) => (value << count) | (value >> (32 - count));
+#endif
+        private void Initialize(uint seed)
+        {
+            HashSizeValue = 32;
+            _Seed32 = seed;
+            Initialize();
+        }
+
+    }
+
+    /// <summary>
+    /// Represents the class which provides a implementation of the xxHash64 algorithm.
+    /// </summary>
+    /// <threadsafety static="true" instance="false"/>
+    public sealed class XXHash64 : HashAlgorithm
+    {
+        private const ulong PRIME64_1 = 11400714785074694791UL;
+        private const ulong PRIME64_2 = 14029467366897019727UL;
+        private const ulong PRIME64_3 = 1609587929392839161UL;
+        private const ulong PRIME64_4 = 9650029242287828579UL;
+        private const ulong PRIME64_5 = 2870177450012600261UL;
+
+        private static readonly Func<byte[], int, uint> FuncGetLittleEndianUInt32;
+        private static readonly Func<byte[], int, ulong> FuncGetLittleEndianUInt64;
+        private static readonly Func<ulong, ulong> FuncGetFinalHashUInt64;
+
+        private ulong _Seed64;
+
+        private ulong _ACC64_1;
+        private ulong _ACC64_2;
+        private ulong _ACC64_3;
+        private ulong _ACC64_4;
+        private ulong _Hash64;
+
+        private int _RemainingLength;
+        private long _TotalLength;
+        private int _CurrentIndex;
+        private byte[] _CurrentArray;
+
+
+
+        static XXHash64()
+        {
+            if (BitConverter.IsLittleEndian)
+            {
+                FuncGetLittleEndianUInt32 = new Func<byte[], int, uint>((x, i) =>
+                {
+                    unsafe
+                    {
+                        fixed (byte* array = x)
+                        {
+                            return *(uint*)(array + i);
+                        }
+                    }
+                });
+                FuncGetLittleEndianUInt64 = new Func<byte[], int, ulong>((x, i) =>
+                {
+                    unsafe
+                    {
+                        fixed (byte* array = x)
+                        {
+                            return *(ulong*)(array + i);
+                        }
+                    }
+                });
+                FuncGetFinalHashUInt64 = new Func<ulong, ulong>(i => (i & 0x00000000000000FFUL) << 56 | (i & 0x000000000000FF00UL) << 40 | (i & 0x0000000000FF0000UL) << 24 | (i & 0x00000000FF000000UL) << 8 | (i & 0x000000FF00000000UL) >> 8 | (i & 0x0000FF0000000000UL) >> 24 | (i & 0x00FF000000000000UL) >> 40 | (i & 0xFF00000000000000UL) >> 56);
+            }
+            else
+            {
+                FuncGetLittleEndianUInt32 = new Func<byte[], int, uint>((x, i) =>
+                {
+                    unsafe
+                    {
+                        fixed (byte* array = x)
+                        {
+                            return (uint)(array[i++] | (array[i++] << 8) | (array[i++] << 16) | (array[i] << 24));
+                        }
+                    }
+                });
+                FuncGetLittleEndianUInt64 = new Func<byte[], int, ulong>((x, i) =>
+                {
+                    unsafe
+                    {
+                        fixed (byte* array = x)
+                        {
+                            return array[i++] | ((ulong)array[i++] << 8) | ((ulong)array[i++] << 16) | ((ulong)array[i++] << 24) | ((ulong)array[i++] << 32) | ((ulong)array[i++] << 40) | ((ulong)array[i++] << 48) | ((ulong)array[i] << 56);
+                        }
+                    }
+                });
+                FuncGetFinalHashUInt64 = new Func<ulong, ulong>(i => i);
+            }
+        }
+
+        /// <summary>
+        /// Creates an instance of <see cref="XXHash64"/> class by default seed(0).
+        /// </summary>
+        /// <returns></returns>
+        public new static XXHash64 Create() => new XXHash64();
+
+        /// <summary>
+        /// Creates an instance of the specified implementation of XXHash64 algorithm.
+        /// <para>This method always throws <see cref="NotSupportedException"/>. </para>
+        /// </summary>
+        /// <param name="algName">The hash algorithm implementation to use.</param>
+        /// <returns>This method always throws <see cref="NotSupportedException"/>. </returns>
+        /// <exception cref="NotSupportedException">This method is not be supported.</exception>
+        public new static XXHash64 Create(string algName) => throw new NotSupportedException("This method is not be supported.");
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="XXHash64"/> class by default seed(0).
+        /// </summary>
+        public XXHash64() => Initialize(0);
+
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="XXHash64"/> class, and sets the <see cref="Seed"/> to the specified value.
+        /// </summary>
+        /// <param name="seed">Represent the seed to be used for xxHash64 computing.</param>
+        public XXHash64(uint seed) => Initialize(seed);
+
+
+        /// <summary>
+        /// Gets the <see cref="ulong"/> value of the computed hash code.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">Computation has not yet completed.</exception>
+        public ulong HashUInt64 => State == 0 ? _Hash64 : throw new InvalidOperationException("Computation has not yet completed.");
+
+        /// <summary>
+        ///  Gets or sets the value of seed used by xxHash64 algorithm.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">Computation has not yet completed.</exception>
+        public ulong Seed
+        {
+            get => _Seed64;
+            set
+            {
+                if (value != _Seed64)
+                {
+                    if (State != 0) throw new InvalidOperationException("Computation has not yet completed.");
+                    _Seed64 = value;
+                    Initialize();
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Initializes this instance for new hash computing.
+        /// </summary>
+        public override void Initialize()
+        {
+            _ACC64_1 = _Seed64 + PRIME64_1 + PRIME64_2;
+            _ACC64_2 = _Seed64 + PRIME64_2;
+            _ACC64_3 = _Seed64 + 0;
+            _ACC64_4 = _Seed64 - PRIME64_1;
+        }
+
+        /// <summary>
+        /// Routes data written to the object into the hash algorithm for computing the hash.
+        /// </summary>
+        /// <param name="array">The input to compute the hash code for.</param>
+        /// <param name="ibStart">The offset into the byte array from which to begin using data.</param>
+        /// <param name="cbSize">The number of bytes in the byte array to use as data.</param>
+        protected override void HashCore(byte[] array, int ibStart, int cbSize)
+        {
+            if (State != 1) State = 1;
+            var size = cbSize - ibStart;
+            _RemainingLength = size & 31;
+            if (cbSize >= 32)
+            {
+                var limit = size - _RemainingLength;
+                do
+                {
+                    _ACC64_1 = Round64(_ACC64_1, FuncGetLittleEndianUInt64(array, ibStart));
+                    ibStart += 8;
+                    _ACC64_2 = Round64(_ACC64_2, FuncGetLittleEndianUInt64(array, ibStart));
+                    ibStart += 8;
+                    _ACC64_3 = Round64(_ACC64_3, FuncGetLittleEndianUInt64(array, ibStart));
+                    ibStart += 8;
+                    _ACC64_4 = Round64(_ACC64_4, FuncGetLittleEndianUInt64(array, ibStart));
+                    ibStart += 8;
+                } while (ibStart < limit);
+            }
+            _TotalLength += cbSize;
+            if (_RemainingLength != 0)
+            {
+                _CurrentArray = array;
+                _CurrentIndex = ibStart;
+            }
+        }
+
+        /// <summary>
+        /// Finalizes the hash computation after the last data is processed by the cryptographic stream object.
+        /// </summary>
+        /// <returns>The computed hash code.</returns>
+        protected override byte[] HashFinal()
+        {
+            if (_TotalLength >= 32)
+            {
+#if HIGHER_VERSIONS
+                _Hash64 = RotateLeft64_1(_ACC64_1) + RotateLeft64_7(_ACC64_2) + RotateLeft64_12(_ACC64_3) + RotateLeft64_18(_ACC64_4);
+#else
+
+                _Hash64 = RotateLeft64(_ACC64_1, 1) + RotateLeft64(_ACC64_2, 7) + RotateLeft64(_ACC64_3, 12) + RotateLeft64(_ACC64_4, 18);
+#endif
+                _Hash64 = MergeRound64(_Hash64, _ACC64_1);
+                _Hash64 = MergeRound64(_Hash64, _ACC64_2);
+                _Hash64 = MergeRound64(_Hash64, _ACC64_3);
+                _Hash64 = MergeRound64(_Hash64, _ACC64_4);
+            }
+            else
+            {
+                _Hash64 = _Seed64 + PRIME64_5;
+            }
+
+            _Hash64 += (ulong)_TotalLength;
+
+            while (_RemainingLength >= 8)
+            {
+#if HIGHER_VERSIONS
+                _Hash64 = RotateLeft64_27(_Hash64 ^ Round64(0, FuncGetLittleEndianUInt64(_CurrentArray, _CurrentIndex))) * PRIME64_1 + PRIME64_4;
+#else
+                _Hash64 = RotateLeft64(_Hash64 ^ Round64(0, FuncGetLittleEndianUInt64(_CurrentArray, _CurrentIndex)), 27) * PRIME64_1 + PRIME64_4;
+#endif
+                _CurrentIndex += 8;
+                _RemainingLength -= 8;
+            }
+
+            while (_RemainingLength >= 4)
+            {
+#if HIGHER_VERSIONS
+                _Hash64 = RotateLeft64_23(_Hash64 ^ (FuncGetLittleEndianUInt32(_CurrentArray, _CurrentIndex) * PRIME64_1)) * PRIME64_2 + PRIME64_3;
+#else
+                _Hash64 = RotateLeft64(_Hash64 ^ (FuncGetLittleEndianUInt32(_CurrentArray, _CurrentIndex) * PRIME64_1), 23) * PRIME64_2 + PRIME64_3;
+#endif
+                _CurrentIndex += 4;
+                _RemainingLength -= 4;
+            }
+
+            unsafe
+            {
+                fixed (byte* arrayPtr = _CurrentArray)
+                {
+                    while (_RemainingLength-- >= 1)
+                    {
+#if HIGHER_VERSIONS
+                        _Hash64 = RotateLeft64_11(_Hash64 ^ (arrayPtr[_CurrentIndex++] * PRIME64_5)) * PRIME64_1;
+#else
+                        _Hash64 = RotateLeft64(_Hash64 ^ (arrayPtr[_CurrentIndex++] * PRIME64_5), 11) * PRIME64_1;
+#endif
+                    }
+                }
+            }
+
+            _Hash64 = (_Hash64 ^ (_Hash64 >> 33)) * PRIME64_2;
+            _Hash64 = (_Hash64 ^ (_Hash64 >> 29)) * PRIME64_3;
+            _Hash64 ^= _Hash64 >> 32;
+
+            _TotalLength = State = 0;
+            return BitConverter.GetBytes(FuncGetFinalHashUInt64(_Hash64));
+        }
+
+#if HIGHER_VERSIONS
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong MergeRound64(ulong input, ulong value) => (input ^ Round64(0, value)) * PRIME64_1 + PRIME64_4;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong Round64(ulong input, ulong value) => RotateLeft64_31(input + (value * PRIME64_2)) * PRIME64_1;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong RotateLeft64_1(ulong value) => (value << 1) | (value >> 63); // _ACC64_1
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong RotateLeft64_7(ulong value) => (value << 7) | (value >> 57); //  _ACC64_2
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong RotateLeft64_11(ulong value) => (value << 11) | (value >> 53);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong RotateLeft64_12(ulong value) => (value << 12) | (value >> 52);// _ACC64_3
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong RotateLeft64_18(ulong value) => (value << 18) | (value >> 46); // _ACC64_4
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong RotateLeft64_23(ulong value) => (value << 23) | (value >> 41);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong RotateLeft64_27(ulong value) => (value << 27) | (value >> 37);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong RotateLeft64_31(ulong value) => (value << 31) | (value >> 33);
+#else
+        private static ulong MergeRound64(ulong input, ulong value) => (input ^ Round64(0, value)) * PRIME64_1 + PRIME64_4;
+
+        private static ulong Round64(ulong input, ulong value) => RotateLeft64(input + (value * PRIME64_2), 31) * PRIME64_1;
+
+        private static ulong RotateLeft64(ulong value, int count) => (value << count) | (value >> (64 - count));
+#endif
+
+
+        private void Initialize(ulong seed)
+        {
+            HashSizeValue = 64;
+            _Seed64 = seed;
+            Initialize();
+        }
+
+
+    }
+
+}

SCHALE.Common/FlatData/AcademyFavorScheduleExcel.cs

@@ -0,0 +1,147 @@
+// <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 AcademyFavorScheduleExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyFavorScheduleExcel GetRootAsAcademyFavorScheduleExcel(ByteBuffer _bb) { return GetRootAsAcademyFavorScheduleExcel(_bb, new AcademyFavorScheduleExcel()); }
+  public static AcademyFavorScheduleExcel GetRootAsAcademyFavorScheduleExcel(ByteBuffer _bb, AcademyFavorScheduleExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyFavorScheduleExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long Id { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long CharacterId { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long ScheduleGroupId { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long OrderInGroup { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string Location { get { int o = __p.__offset(12); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetLocationBytes() { return __p.__vector_as_span<byte>(12, 1); }
+#else
+  public ArraySegment<byte>? GetLocationBytes() { return __p.__vector_as_arraysegment(12); }
+#endif
+  public byte[] GetLocationArray() { return __p.__vector_as_array<byte>(12); }
+  public uint LocalizeScenarioId { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public long FavorRank { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long SecretStoneAmount { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long ScenarioSriptGroupId { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.ParcelType RewardParcelType(int j) { int o = __p.__offset(22); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.ParcelType)0; }
+  public int RewardParcelTypeLength { get { int o = __p.__offset(22); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<SCHALE.Common.FlatData.ParcelType> GetRewardParcelTypeBytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.ParcelType>(22, 4); }
+#else
+  public ArraySegment<byte>? GetRewardParcelTypeBytes() { return __p.__vector_as_arraysegment(22); }
+#endif
+  public SCHALE.Common.FlatData.ParcelType[] GetRewardParcelTypeArray() { int o = __p.__offset(22); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.ParcelType[] a = new SCHALE.Common.FlatData.ParcelType[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(p + i * 4); } return a; }
+  public long RewardParcelId(int j) { int o = __p.__offset(24); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int RewardParcelIdLength { get { int o = __p.__offset(24); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetRewardParcelIdBytes() { return __p.__vector_as_span<long>(24, 8); }
+#else
+  public ArraySegment<byte>? GetRewardParcelIdBytes() { return __p.__vector_as_arraysegment(24); }
+#endif
+  public long[] GetRewardParcelIdArray() { return __p.__vector_as_array<long>(24); }
+  public long RewardAmount(int j) { int o = __p.__offset(26); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int RewardAmountLength { get { int o = __p.__offset(26); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetRewardAmountBytes() { return __p.__vector_as_span<long>(26, 8); }
+#else
+  public ArraySegment<byte>? GetRewardAmountBytes() { return __p.__vector_as_arraysegment(26); }
+#endif
+  public long[] GetRewardAmountArray() { return __p.__vector_as_array<long>(26); }
+
+  public static Offset<SCHALE.Common.FlatData.AcademyFavorScheduleExcel> CreateAcademyFavorScheduleExcel(FlatBufferBuilder builder,
+      long Id = 0,
+      long CharacterId = 0,
+      long ScheduleGroupId = 0,
+      long OrderInGroup = 0,
+      StringOffset LocationOffset = default(StringOffset),
+      uint LocalizeScenarioId = 0,
+      long FavorRank = 0,
+      long SecretStoneAmount = 0,
+      long ScenarioSriptGroupId = 0,
+      VectorOffset RewardParcelTypeOffset = default(VectorOffset),
+      VectorOffset RewardParcelIdOffset = default(VectorOffset),
+      VectorOffset RewardAmountOffset = default(VectorOffset)) {
+    builder.StartTable(12);
+    AcademyFavorScheduleExcel.AddScenarioSriptGroupId(builder, ScenarioSriptGroupId);
+    AcademyFavorScheduleExcel.AddSecretStoneAmount(builder, SecretStoneAmount);
+    AcademyFavorScheduleExcel.AddFavorRank(builder, FavorRank);
+    AcademyFavorScheduleExcel.AddOrderInGroup(builder, OrderInGroup);
+    AcademyFavorScheduleExcel.AddScheduleGroupId(builder, ScheduleGroupId);
+    AcademyFavorScheduleExcel.AddCharacterId(builder, CharacterId);
+    AcademyFavorScheduleExcel.AddId(builder, Id);
+    AcademyFavorScheduleExcel.AddRewardAmount(builder, RewardAmountOffset);
+    AcademyFavorScheduleExcel.AddRewardParcelId(builder, RewardParcelIdOffset);
+    AcademyFavorScheduleExcel.AddRewardParcelType(builder, RewardParcelTypeOffset);
+    AcademyFavorScheduleExcel.AddLocalizeScenarioId(builder, LocalizeScenarioId);
+    AcademyFavorScheduleExcel.AddLocation(builder, LocationOffset);
+    return AcademyFavorScheduleExcel.EndAcademyFavorScheduleExcel(builder);
+  }
+
+  public static void StartAcademyFavorScheduleExcel(FlatBufferBuilder builder) { builder.StartTable(12); }
+  public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
+  public static void AddCharacterId(FlatBufferBuilder builder, long characterId) { builder.AddLong(1, characterId, 0); }
+  public static void AddScheduleGroupId(FlatBufferBuilder builder, long scheduleGroupId) { builder.AddLong(2, scheduleGroupId, 0); }
+  public static void AddOrderInGroup(FlatBufferBuilder builder, long orderInGroup) { builder.AddLong(3, orderInGroup, 0); }
+  public static void AddLocation(FlatBufferBuilder builder, StringOffset locationOffset) { builder.AddOffset(4, locationOffset.Value, 0); }
+  public static void AddLocalizeScenarioId(FlatBufferBuilder builder, uint localizeScenarioId) { builder.AddUint(5, localizeScenarioId, 0); }
+  public static void AddFavorRank(FlatBufferBuilder builder, long favorRank) { builder.AddLong(6, favorRank, 0); }
+  public static void AddSecretStoneAmount(FlatBufferBuilder builder, long secretStoneAmount) { builder.AddLong(7, secretStoneAmount, 0); }
+  public static void AddScenarioSriptGroupId(FlatBufferBuilder builder, long scenarioSriptGroupId) { builder.AddLong(8, scenarioSriptGroupId, 0); }
+  public static void AddRewardParcelType(FlatBufferBuilder builder, VectorOffset rewardParcelTypeOffset) { builder.AddOffset(9, rewardParcelTypeOffset.Value, 0); }
+  public static VectorOffset CreateRewardParcelTypeVector(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt((int)data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, ArraySegment<SCHALE.Common.FlatData.ParcelType> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<SCHALE.Common.FlatData.ParcelType>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardParcelTypeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddRewardParcelId(FlatBufferBuilder builder, VectorOffset rewardParcelIdOffset) { builder.AddOffset(10, rewardParcelIdOffset.Value, 0); }
+  public static VectorOffset CreateRewardParcelIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardParcelIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddRewardAmount(FlatBufferBuilder builder, VectorOffset rewardAmountOffset) { builder.AddOffset(11, rewardAmountOffset.Value, 0); }
+  public static VectorOffset CreateRewardAmountVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateRewardAmountVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardAmountVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardAmountVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardAmountVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static Offset<SCHALE.Common.FlatData.AcademyFavorScheduleExcel> EndAcademyFavorScheduleExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyFavorScheduleExcel>(o);
+  }
+}
+
+
+static public class AcademyFavorScheduleExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*CharacterId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*ScheduleGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*OrderInGroup*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 12 /*Location*/, false)
+      && verifier.VerifyField(tablePos, 14 /*LocalizeScenarioId*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 16 /*FavorRank*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 18 /*SecretStoneAmount*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 20 /*ScenarioSriptGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 22 /*RewardParcelType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 24 /*RewardParcelId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 26 /*RewardAmount*/, 8 /*long*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyFavorScheduleExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 AcademyFavorScheduleExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyFavorScheduleExcelTable GetRootAsAcademyFavorScheduleExcelTable(ByteBuffer _bb) { return GetRootAsAcademyFavorScheduleExcelTable(_bb, new AcademyFavorScheduleExcelTable()); }
+  public static AcademyFavorScheduleExcelTable GetRootAsAcademyFavorScheduleExcelTable(ByteBuffer _bb, AcademyFavorScheduleExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyFavorScheduleExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.AcademyFavorScheduleExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.AcademyFavorScheduleExcel?)(new SCHALE.Common.FlatData.AcademyFavorScheduleExcel()).__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.AcademyFavorScheduleExcelTable> CreateAcademyFavorScheduleExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    AcademyFavorScheduleExcelTable.AddDataList(builder, DataListOffset);
+    return AcademyFavorScheduleExcelTable.EndAcademyFavorScheduleExcelTable(builder);
+  }
+
+  public static void StartAcademyFavorScheduleExcelTable(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.AcademyFavorScheduleExcel>[] 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.AcademyFavorScheduleExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AcademyFavorScheduleExcel>> 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.AcademyFavorScheduleExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AcademyFavorScheduleExcelTable> EndAcademyFavorScheduleExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyFavorScheduleExcelTable>(o);
+  }
+}
+
+
+static public class AcademyFavorScheduleExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.AcademyFavorScheduleExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyLocationExcel.cs

@@ -0,0 +1,126 @@
+// <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 AcademyLocationExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyLocationExcel GetRootAsAcademyLocationExcel(ByteBuffer _bb) { return GetRootAsAcademyLocationExcel(_bb, new AcademyLocationExcel()); }
+  public static AcademyLocationExcel GetRootAsAcademyLocationExcel(ByteBuffer _bb, AcademyLocationExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyLocationExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long Id { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public uint LocalizeEtcId { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public string PrefabPath { get { int o = __p.__offset(8); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetPrefabPathBytes() { return __p.__vector_as_span<byte>(8, 1); }
+#else
+  public ArraySegment<byte>? GetPrefabPathBytes() { return __p.__vector_as_arraysegment(8); }
+#endif
+  public byte[] GetPrefabPathArray() { return __p.__vector_as_array<byte>(8); }
+  public string IconImagePath { get { int o = __p.__offset(10); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetIconImagePathBytes() { return __p.__vector_as_span<byte>(10, 1); }
+#else
+  public ArraySegment<byte>? GetIconImagePathBytes() { return __p.__vector_as_arraysegment(10); }
+#endif
+  public byte[] GetIconImagePathArray() { return __p.__vector_as_array<byte>(10); }
+  public SCHALE.Common.FlatData.School OpenCondition(int j) { int o = __p.__offset(12); return o != 0 ? (SCHALE.Common.FlatData.School)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.School)0; }
+  public int OpenConditionLength { get { int o = __p.__offset(12); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<SCHALE.Common.FlatData.School> GetOpenConditionBytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.School>(12, 4); }
+#else
+  public ArraySegment<byte>? GetOpenConditionBytes() { return __p.__vector_as_arraysegment(12); }
+#endif
+  public SCHALE.Common.FlatData.School[] GetOpenConditionArray() { int o = __p.__offset(12); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.School[] a = new SCHALE.Common.FlatData.School[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.School)__p.bb.GetInt(p + i * 4); } return a; }
+  public long OpenConditionCount(int j) { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int OpenConditionCountLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetOpenConditionCountBytes() { return __p.__vector_as_span<long>(14, 8); }
+#else
+  public ArraySegment<byte>? GetOpenConditionCountBytes() { return __p.__vector_as_arraysegment(14); }
+#endif
+  public long[] GetOpenConditionCountArray() { return __p.__vector_as_array<long>(14); }
+  public SCHALE.Common.FlatData.ParcelType RewardParcelType { get { int o = __p.__offset(16); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.ParcelType.None; } }
+  public long RewardParcelId { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long OpenTeacherRank { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+
+  public static Offset<SCHALE.Common.FlatData.AcademyLocationExcel> CreateAcademyLocationExcel(FlatBufferBuilder builder,
+      long Id = 0,
+      uint LocalizeEtcId = 0,
+      StringOffset PrefabPathOffset = default(StringOffset),
+      StringOffset IconImagePathOffset = default(StringOffset),
+      VectorOffset OpenConditionOffset = default(VectorOffset),
+      VectorOffset OpenConditionCountOffset = default(VectorOffset),
+      SCHALE.Common.FlatData.ParcelType RewardParcelType = SCHALE.Common.FlatData.ParcelType.None,
+      long RewardParcelId = 0,
+      long OpenTeacherRank = 0) {
+    builder.StartTable(9);
+    AcademyLocationExcel.AddOpenTeacherRank(builder, OpenTeacherRank);
+    AcademyLocationExcel.AddRewardParcelId(builder, RewardParcelId);
+    AcademyLocationExcel.AddId(builder, Id);
+    AcademyLocationExcel.AddRewardParcelType(builder, RewardParcelType);
+    AcademyLocationExcel.AddOpenConditionCount(builder, OpenConditionCountOffset);
+    AcademyLocationExcel.AddOpenCondition(builder, OpenConditionOffset);
+    AcademyLocationExcel.AddIconImagePath(builder, IconImagePathOffset);
+    AcademyLocationExcel.AddPrefabPath(builder, PrefabPathOffset);
+    AcademyLocationExcel.AddLocalizeEtcId(builder, LocalizeEtcId);
+    return AcademyLocationExcel.EndAcademyLocationExcel(builder);
+  }
+
+  public static void StartAcademyLocationExcel(FlatBufferBuilder builder) { builder.StartTable(9); }
+  public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
+  public static void AddLocalizeEtcId(FlatBufferBuilder builder, uint localizeEtcId) { builder.AddUint(1, localizeEtcId, 0); }
+  public static void AddPrefabPath(FlatBufferBuilder builder, StringOffset prefabPathOffset) { builder.AddOffset(2, prefabPathOffset.Value, 0); }
+  public static void AddIconImagePath(FlatBufferBuilder builder, StringOffset iconImagePathOffset) { builder.AddOffset(3, iconImagePathOffset.Value, 0); }
+  public static void AddOpenCondition(FlatBufferBuilder builder, VectorOffset openConditionOffset) { builder.AddOffset(4, openConditionOffset.Value, 0); }
+  public static VectorOffset CreateOpenConditionVector(FlatBufferBuilder builder, SCHALE.Common.FlatData.School[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt((int)data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateOpenConditionVectorBlock(FlatBufferBuilder builder, SCHALE.Common.FlatData.School[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateOpenConditionVectorBlock(FlatBufferBuilder builder, ArraySegment<SCHALE.Common.FlatData.School> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateOpenConditionVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<SCHALE.Common.FlatData.School>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartOpenConditionVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddOpenConditionCount(FlatBufferBuilder builder, VectorOffset openConditionCountOffset) { builder.AddOffset(5, openConditionCountOffset.Value, 0); }
+  public static VectorOffset CreateOpenConditionCountVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateOpenConditionCountVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateOpenConditionCountVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateOpenConditionCountVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartOpenConditionCountVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddRewardParcelType(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType rewardParcelType) { builder.AddInt(6, (int)rewardParcelType, 0); }
+  public static void AddRewardParcelId(FlatBufferBuilder builder, long rewardParcelId) { builder.AddLong(7, rewardParcelId, 0); }
+  public static void AddOpenTeacherRank(FlatBufferBuilder builder, long openTeacherRank) { builder.AddLong(8, openTeacherRank, 0); }
+  public static Offset<SCHALE.Common.FlatData.AcademyLocationExcel> EndAcademyLocationExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyLocationExcel>(o);
+  }
+}
+
+
+static public class AcademyLocationExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*LocalizeEtcId*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyString(tablePos, 8 /*PrefabPath*/, false)
+      && verifier.VerifyString(tablePos, 10 /*IconImagePath*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 12 /*OpenCondition*/, 4 /*SCHALE.Common.FlatData.School*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 14 /*OpenConditionCount*/, 8 /*long*/, false)
+      && verifier.VerifyField(tablePos, 16 /*RewardParcelType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, 4, false)
+      && verifier.VerifyField(tablePos, 18 /*RewardParcelId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 20 /*OpenTeacherRank*/, 8 /*long*/, 8, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyLocationExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 AcademyLocationExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyLocationExcelTable GetRootAsAcademyLocationExcelTable(ByteBuffer _bb) { return GetRootAsAcademyLocationExcelTable(_bb, new AcademyLocationExcelTable()); }
+  public static AcademyLocationExcelTable GetRootAsAcademyLocationExcelTable(ByteBuffer _bb, AcademyLocationExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyLocationExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.AcademyLocationExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.AcademyLocationExcel?)(new SCHALE.Common.FlatData.AcademyLocationExcel()).__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.AcademyLocationExcelTable> CreateAcademyLocationExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    AcademyLocationExcelTable.AddDataList(builder, DataListOffset);
+    return AcademyLocationExcelTable.EndAcademyLocationExcelTable(builder);
+  }
+
+  public static void StartAcademyLocationExcelTable(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.AcademyLocationExcel>[] 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.AcademyLocationExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AcademyLocationExcel>> 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.AcademyLocationExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AcademyLocationExcelTable> EndAcademyLocationExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyLocationExcelTable>(o);
+  }
+}
+
+
+static public class AcademyLocationExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.AcademyLocationExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyLocationRankExcel.cs

@@ -0,0 +1,60 @@
+// <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 AcademyLocationRankExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyLocationRankExcel GetRootAsAcademyLocationRankExcel(ByteBuffer _bb) { return GetRootAsAcademyLocationRankExcel(_bb, new AcademyLocationRankExcel()); }
+  public static AcademyLocationRankExcel GetRootAsAcademyLocationRankExcel(ByteBuffer _bb, AcademyLocationRankExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyLocationRankExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long Rank { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long RankExp { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long TotalExp { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+
+  public static Offset<SCHALE.Common.FlatData.AcademyLocationRankExcel> CreateAcademyLocationRankExcel(FlatBufferBuilder builder,
+      long Rank = 0,
+      long RankExp = 0,
+      long TotalExp = 0) {
+    builder.StartTable(3);
+    AcademyLocationRankExcel.AddTotalExp(builder, TotalExp);
+    AcademyLocationRankExcel.AddRankExp(builder, RankExp);
+    AcademyLocationRankExcel.AddRank(builder, Rank);
+    return AcademyLocationRankExcel.EndAcademyLocationRankExcel(builder);
+  }
+
+  public static void StartAcademyLocationRankExcel(FlatBufferBuilder builder) { builder.StartTable(3); }
+  public static void AddRank(FlatBufferBuilder builder, long rank) { builder.AddLong(0, rank, 0); }
+  public static void AddRankExp(FlatBufferBuilder builder, long rankExp) { builder.AddLong(1, rankExp, 0); }
+  public static void AddTotalExp(FlatBufferBuilder builder, long totalExp) { builder.AddLong(2, totalExp, 0); }
+  public static Offset<SCHALE.Common.FlatData.AcademyLocationRankExcel> EndAcademyLocationRankExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyLocationRankExcel>(o);
+  }
+}
+
+
+static public class AcademyLocationRankExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Rank*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*RankExp*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*TotalExp*/, 8 /*long*/, 8, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyLocationRankExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 AcademyLocationRankExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyLocationRankExcelTable GetRootAsAcademyLocationRankExcelTable(ByteBuffer _bb) { return GetRootAsAcademyLocationRankExcelTable(_bb, new AcademyLocationRankExcelTable()); }
+  public static AcademyLocationRankExcelTable GetRootAsAcademyLocationRankExcelTable(ByteBuffer _bb, AcademyLocationRankExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyLocationRankExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.AcademyLocationRankExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.AcademyLocationRankExcel?)(new SCHALE.Common.FlatData.AcademyLocationRankExcel()).__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.AcademyLocationRankExcelTable> CreateAcademyLocationRankExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    AcademyLocationRankExcelTable.AddDataList(builder, DataListOffset);
+    return AcademyLocationRankExcelTable.EndAcademyLocationRankExcelTable(builder);
+  }
+
+  public static void StartAcademyLocationRankExcelTable(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.AcademyLocationRankExcel>[] 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.AcademyLocationRankExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AcademyLocationRankExcel>> 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.AcademyLocationRankExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AcademyLocationRankExcelTable> EndAcademyLocationRankExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyLocationRankExcelTable>(o);
+  }
+}
+
+
+static public class AcademyLocationRankExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.AcademyLocationRankExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyMessageConditions.cs

@@ -0,0 +1,18 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum AcademyMessageConditions : int
+{
+  None = 0,
+  FavorRankUp = 1,
+  AcademySchedule = 2,
+  Answer = 3,
+  Feedback = 4,
+};
+
+
+}

SCHALE.Common/FlatData/AcademyMessageTypes.cs

@@ -0,0 +1,16 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum AcademyMessageTypes : int
+{
+  None = 0,
+  Text = 1,
+  Image = 2,
+};
+
+
+}

SCHALE.Common/FlatData/AcademyMessanger1Excel.cs

@@ -0,0 +1,133 @@
+// <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 AcademyMessanger1Excel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyMessanger1Excel GetRootAsAcademyMessanger1Excel(ByteBuffer _bb) { return GetRootAsAcademyMessanger1Excel(_bb, new AcademyMessanger1Excel()); }
+  public static AcademyMessanger1Excel GetRootAsAcademyMessanger1Excel(ByteBuffer _bb, AcademyMessanger1Excel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyMessanger1Excel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long MessageGroupId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long Id { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long CharacterId { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.AcademyMessageConditions MessageCondition { get { int o = __p.__offset(10); return o != 0 ? (SCHALE.Common.FlatData.AcademyMessageConditions)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.AcademyMessageConditions.None; } }
+  public long ConditionValue { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long PreConditionGroupId { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long PreConditionFavorScheduleId { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long FavorScheduleId { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long NextGroupId { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long FeedbackTimeMillisec { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.AcademyMessageTypes MessageType { get { int o = __p.__offset(24); return o != 0 ? (SCHALE.Common.FlatData.AcademyMessageTypes)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.AcademyMessageTypes.None; } }
+  public string ImagePath { get { int o = __p.__offset(26); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetImagePathBytes() { return __p.__vector_as_span<byte>(26, 1); }
+#else
+  public ArraySegment<byte>? GetImagePathBytes() { return __p.__vector_as_arraysegment(26); }
+#endif
+  public byte[] GetImagePathArray() { return __p.__vector_as_array<byte>(26); }
+  public string MessageKR { get { int o = __p.__offset(28); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetMessageKRBytes() { return __p.__vector_as_span<byte>(28, 1); }
+#else
+  public ArraySegment<byte>? GetMessageKRBytes() { return __p.__vector_as_arraysegment(28); }
+#endif
+  public byte[] GetMessageKRArray() { return __p.__vector_as_array<byte>(28); }
+  public string MessageJP { get { int o = __p.__offset(30); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetMessageJPBytes() { return __p.__vector_as_span<byte>(30, 1); }
+#else
+  public ArraySegment<byte>? GetMessageJPBytes() { return __p.__vector_as_arraysegment(30); }
+#endif
+  public byte[] GetMessageJPArray() { return __p.__vector_as_array<byte>(30); }
+
+  public static Offset<SCHALE.Common.FlatData.AcademyMessanger1Excel> CreateAcademyMessanger1Excel(FlatBufferBuilder builder,
+      long MessageGroupId = 0,
+      long Id = 0,
+      long CharacterId = 0,
+      SCHALE.Common.FlatData.AcademyMessageConditions MessageCondition = SCHALE.Common.FlatData.AcademyMessageConditions.None,
+      long ConditionValue = 0,
+      long PreConditionGroupId = 0,
+      long PreConditionFavorScheduleId = 0,
+      long FavorScheduleId = 0,
+      long NextGroupId = 0,
+      long FeedbackTimeMillisec = 0,
+      SCHALE.Common.FlatData.AcademyMessageTypes MessageType = SCHALE.Common.FlatData.AcademyMessageTypes.None,
+      StringOffset ImagePathOffset = default(StringOffset),
+      StringOffset MessageKROffset = default(StringOffset),
+      StringOffset MessageJPOffset = default(StringOffset)) {
+    builder.StartTable(14);
+    AcademyMessanger1Excel.AddFeedbackTimeMillisec(builder, FeedbackTimeMillisec);
+    AcademyMessanger1Excel.AddNextGroupId(builder, NextGroupId);
+    AcademyMessanger1Excel.AddFavorScheduleId(builder, FavorScheduleId);
+    AcademyMessanger1Excel.AddPreConditionFavorScheduleId(builder, PreConditionFavorScheduleId);
+    AcademyMessanger1Excel.AddPreConditionGroupId(builder, PreConditionGroupId);
+    AcademyMessanger1Excel.AddConditionValue(builder, ConditionValue);
+    AcademyMessanger1Excel.AddCharacterId(builder, CharacterId);
+    AcademyMessanger1Excel.AddId(builder, Id);
+    AcademyMessanger1Excel.AddMessageGroupId(builder, MessageGroupId);
+    AcademyMessanger1Excel.AddMessageJP(builder, MessageJPOffset);
+    AcademyMessanger1Excel.AddMessageKR(builder, MessageKROffset);
+    AcademyMessanger1Excel.AddImagePath(builder, ImagePathOffset);
+    AcademyMessanger1Excel.AddMessageType(builder, MessageType);
+    AcademyMessanger1Excel.AddMessageCondition(builder, MessageCondition);
+    return AcademyMessanger1Excel.EndAcademyMessanger1Excel(builder);
+  }
+
+  public static void StartAcademyMessanger1Excel(FlatBufferBuilder builder) { builder.StartTable(14); }
+  public static void AddMessageGroupId(FlatBufferBuilder builder, long messageGroupId) { builder.AddLong(0, messageGroupId, 0); }
+  public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(1, id, 0); }
+  public static void AddCharacterId(FlatBufferBuilder builder, long characterId) { builder.AddLong(2, characterId, 0); }
+  public static void AddMessageCondition(FlatBufferBuilder builder, SCHALE.Common.FlatData.AcademyMessageConditions messageCondition) { builder.AddInt(3, (int)messageCondition, 0); }
+  public static void AddConditionValue(FlatBufferBuilder builder, long conditionValue) { builder.AddLong(4, conditionValue, 0); }
+  public static void AddPreConditionGroupId(FlatBufferBuilder builder, long preConditionGroupId) { builder.AddLong(5, preConditionGroupId, 0); }
+  public static void AddPreConditionFavorScheduleId(FlatBufferBuilder builder, long preConditionFavorScheduleId) { builder.AddLong(6, preConditionFavorScheduleId, 0); }
+  public static void AddFavorScheduleId(FlatBufferBuilder builder, long favorScheduleId) { builder.AddLong(7, favorScheduleId, 0); }
+  public static void AddNextGroupId(FlatBufferBuilder builder, long nextGroupId) { builder.AddLong(8, nextGroupId, 0); }
+  public static void AddFeedbackTimeMillisec(FlatBufferBuilder builder, long feedbackTimeMillisec) { builder.AddLong(9, feedbackTimeMillisec, 0); }
+  public static void AddMessageType(FlatBufferBuilder builder, SCHALE.Common.FlatData.AcademyMessageTypes messageType) { builder.AddInt(10, (int)messageType, 0); }
+  public static void AddImagePath(FlatBufferBuilder builder, StringOffset imagePathOffset) { builder.AddOffset(11, imagePathOffset.Value, 0); }
+  public static void AddMessageKR(FlatBufferBuilder builder, StringOffset messageKROffset) { builder.AddOffset(12, messageKROffset.Value, 0); }
+  public static void AddMessageJP(FlatBufferBuilder builder, StringOffset messageJPOffset) { builder.AddOffset(13, messageJPOffset.Value, 0); }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessanger1Excel> EndAcademyMessanger1Excel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyMessanger1Excel>(o);
+  }
+}
+
+
+static public class AcademyMessanger1ExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*MessageGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*CharacterId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*MessageCondition*/, 4 /*SCHALE.Common.FlatData.AcademyMessageConditions*/, 4, false)
+      && verifier.VerifyField(tablePos, 12 /*ConditionValue*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 14 /*PreConditionGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 16 /*PreConditionFavorScheduleId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 18 /*FavorScheduleId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 20 /*NextGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 22 /*FeedbackTimeMillisec*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 24 /*MessageType*/, 4 /*SCHALE.Common.FlatData.AcademyMessageTypes*/, 4, false)
+      && verifier.VerifyString(tablePos, 26 /*ImagePath*/, false)
+      && verifier.VerifyString(tablePos, 28 /*MessageKR*/, false)
+      && verifier.VerifyString(tablePos, 30 /*MessageJP*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyMessanger1ExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 AcademyMessanger1ExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyMessanger1ExcelTable GetRootAsAcademyMessanger1ExcelTable(ByteBuffer _bb) { return GetRootAsAcademyMessanger1ExcelTable(_bb, new AcademyMessanger1ExcelTable()); }
+  public static AcademyMessanger1ExcelTable GetRootAsAcademyMessanger1ExcelTable(ByteBuffer _bb, AcademyMessanger1ExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyMessanger1ExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.AcademyMessanger1Excel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.AcademyMessanger1Excel?)(new SCHALE.Common.FlatData.AcademyMessanger1Excel()).__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.AcademyMessanger1ExcelTable> CreateAcademyMessanger1ExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    AcademyMessanger1ExcelTable.AddDataList(builder, DataListOffset);
+    return AcademyMessanger1ExcelTable.EndAcademyMessanger1ExcelTable(builder);
+  }
+
+  public static void StartAcademyMessanger1ExcelTable(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.AcademyMessanger1Excel>[] 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.AcademyMessanger1Excel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AcademyMessanger1Excel>> 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.AcademyMessanger1Excel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessanger1ExcelTable> EndAcademyMessanger1ExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyMessanger1ExcelTable>(o);
+  }
+}
+
+
+static public class AcademyMessanger1ExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.AcademyMessanger1ExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyMessanger2Excel.cs

@@ -0,0 +1,133 @@
+// <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 AcademyMessanger2Excel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyMessanger2Excel GetRootAsAcademyMessanger2Excel(ByteBuffer _bb) { return GetRootAsAcademyMessanger2Excel(_bb, new AcademyMessanger2Excel()); }
+  public static AcademyMessanger2Excel GetRootAsAcademyMessanger2Excel(ByteBuffer _bb, AcademyMessanger2Excel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyMessanger2Excel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long MessageGroupId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long Id { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long CharacterId { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.AcademyMessageConditions MessageCondition { get { int o = __p.__offset(10); return o != 0 ? (SCHALE.Common.FlatData.AcademyMessageConditions)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.AcademyMessageConditions.None; } }
+  public long ConditionValue { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long PreConditionGroupId { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long PreConditionFavorScheduleId { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long FavorScheduleId { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long NextGroupId { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long FeedbackTimeMillisec { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.AcademyMessageTypes MessageType { get { int o = __p.__offset(24); return o != 0 ? (SCHALE.Common.FlatData.AcademyMessageTypes)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.AcademyMessageTypes.None; } }
+  public string ImagePath { get { int o = __p.__offset(26); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetImagePathBytes() { return __p.__vector_as_span<byte>(26, 1); }
+#else
+  public ArraySegment<byte>? GetImagePathBytes() { return __p.__vector_as_arraysegment(26); }
+#endif
+  public byte[] GetImagePathArray() { return __p.__vector_as_array<byte>(26); }
+  public string MessageKR { get { int o = __p.__offset(28); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetMessageKRBytes() { return __p.__vector_as_span<byte>(28, 1); }
+#else
+  public ArraySegment<byte>? GetMessageKRBytes() { return __p.__vector_as_arraysegment(28); }
+#endif
+  public byte[] GetMessageKRArray() { return __p.__vector_as_array<byte>(28); }
+  public string MessageJP { get { int o = __p.__offset(30); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetMessageJPBytes() { return __p.__vector_as_span<byte>(30, 1); }
+#else
+  public ArraySegment<byte>? GetMessageJPBytes() { return __p.__vector_as_arraysegment(30); }
+#endif
+  public byte[] GetMessageJPArray() { return __p.__vector_as_array<byte>(30); }
+
+  public static Offset<SCHALE.Common.FlatData.AcademyMessanger2Excel> CreateAcademyMessanger2Excel(FlatBufferBuilder builder,
+      long MessageGroupId = 0,
+      long Id = 0,
+      long CharacterId = 0,
+      SCHALE.Common.FlatData.AcademyMessageConditions MessageCondition = SCHALE.Common.FlatData.AcademyMessageConditions.None,
+      long ConditionValue = 0,
+      long PreConditionGroupId = 0,
+      long PreConditionFavorScheduleId = 0,
+      long FavorScheduleId = 0,
+      long NextGroupId = 0,
+      long FeedbackTimeMillisec = 0,
+      SCHALE.Common.FlatData.AcademyMessageTypes MessageType = SCHALE.Common.FlatData.AcademyMessageTypes.None,
+      StringOffset ImagePathOffset = default(StringOffset),
+      StringOffset MessageKROffset = default(StringOffset),
+      StringOffset MessageJPOffset = default(StringOffset)) {
+    builder.StartTable(14);
+    AcademyMessanger2Excel.AddFeedbackTimeMillisec(builder, FeedbackTimeMillisec);
+    AcademyMessanger2Excel.AddNextGroupId(builder, NextGroupId);
+    AcademyMessanger2Excel.AddFavorScheduleId(builder, FavorScheduleId);
+    AcademyMessanger2Excel.AddPreConditionFavorScheduleId(builder, PreConditionFavorScheduleId);
+    AcademyMessanger2Excel.AddPreConditionGroupId(builder, PreConditionGroupId);
+    AcademyMessanger2Excel.AddConditionValue(builder, ConditionValue);
+    AcademyMessanger2Excel.AddCharacterId(builder, CharacterId);
+    AcademyMessanger2Excel.AddId(builder, Id);
+    AcademyMessanger2Excel.AddMessageGroupId(builder, MessageGroupId);
+    AcademyMessanger2Excel.AddMessageJP(builder, MessageJPOffset);
+    AcademyMessanger2Excel.AddMessageKR(builder, MessageKROffset);
+    AcademyMessanger2Excel.AddImagePath(builder, ImagePathOffset);
+    AcademyMessanger2Excel.AddMessageType(builder, MessageType);
+    AcademyMessanger2Excel.AddMessageCondition(builder, MessageCondition);
+    return AcademyMessanger2Excel.EndAcademyMessanger2Excel(builder);
+  }
+
+  public static void StartAcademyMessanger2Excel(FlatBufferBuilder builder) { builder.StartTable(14); }
+  public static void AddMessageGroupId(FlatBufferBuilder builder, long messageGroupId) { builder.AddLong(0, messageGroupId, 0); }
+  public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(1, id, 0); }
+  public static void AddCharacterId(FlatBufferBuilder builder, long characterId) { builder.AddLong(2, characterId, 0); }
+  public static void AddMessageCondition(FlatBufferBuilder builder, SCHALE.Common.FlatData.AcademyMessageConditions messageCondition) { builder.AddInt(3, (int)messageCondition, 0); }
+  public static void AddConditionValue(FlatBufferBuilder builder, long conditionValue) { builder.AddLong(4, conditionValue, 0); }
+  public static void AddPreConditionGroupId(FlatBufferBuilder builder, long preConditionGroupId) { builder.AddLong(5, preConditionGroupId, 0); }
+  public static void AddPreConditionFavorScheduleId(FlatBufferBuilder builder, long preConditionFavorScheduleId) { builder.AddLong(6, preConditionFavorScheduleId, 0); }
+  public static void AddFavorScheduleId(FlatBufferBuilder builder, long favorScheduleId) { builder.AddLong(7, favorScheduleId, 0); }
+  public static void AddNextGroupId(FlatBufferBuilder builder, long nextGroupId) { builder.AddLong(8, nextGroupId, 0); }
+  public static void AddFeedbackTimeMillisec(FlatBufferBuilder builder, long feedbackTimeMillisec) { builder.AddLong(9, feedbackTimeMillisec, 0); }
+  public static void AddMessageType(FlatBufferBuilder builder, SCHALE.Common.FlatData.AcademyMessageTypes messageType) { builder.AddInt(10, (int)messageType, 0); }
+  public static void AddImagePath(FlatBufferBuilder builder, StringOffset imagePathOffset) { builder.AddOffset(11, imagePathOffset.Value, 0); }
+  public static void AddMessageKR(FlatBufferBuilder builder, StringOffset messageKROffset) { builder.AddOffset(12, messageKROffset.Value, 0); }
+  public static void AddMessageJP(FlatBufferBuilder builder, StringOffset messageJPOffset) { builder.AddOffset(13, messageJPOffset.Value, 0); }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessanger2Excel> EndAcademyMessanger2Excel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyMessanger2Excel>(o);
+  }
+}
+
+
+static public class AcademyMessanger2ExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*MessageGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*CharacterId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*MessageCondition*/, 4 /*SCHALE.Common.FlatData.AcademyMessageConditions*/, 4, false)
+      && verifier.VerifyField(tablePos, 12 /*ConditionValue*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 14 /*PreConditionGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 16 /*PreConditionFavorScheduleId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 18 /*FavorScheduleId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 20 /*NextGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 22 /*FeedbackTimeMillisec*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 24 /*MessageType*/, 4 /*SCHALE.Common.FlatData.AcademyMessageTypes*/, 4, false)
+      && verifier.VerifyString(tablePos, 26 /*ImagePath*/, false)
+      && verifier.VerifyString(tablePos, 28 /*MessageKR*/, false)
+      && verifier.VerifyString(tablePos, 30 /*MessageJP*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyMessanger2ExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 AcademyMessanger2ExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyMessanger2ExcelTable GetRootAsAcademyMessanger2ExcelTable(ByteBuffer _bb) { return GetRootAsAcademyMessanger2ExcelTable(_bb, new AcademyMessanger2ExcelTable()); }
+  public static AcademyMessanger2ExcelTable GetRootAsAcademyMessanger2ExcelTable(ByteBuffer _bb, AcademyMessanger2ExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyMessanger2ExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.AcademyMessanger2Excel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.AcademyMessanger2Excel?)(new SCHALE.Common.FlatData.AcademyMessanger2Excel()).__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.AcademyMessanger2ExcelTable> CreateAcademyMessanger2ExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    AcademyMessanger2ExcelTable.AddDataList(builder, DataListOffset);
+    return AcademyMessanger2ExcelTable.EndAcademyMessanger2ExcelTable(builder);
+  }
+
+  public static void StartAcademyMessanger2ExcelTable(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.AcademyMessanger2Excel>[] 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.AcademyMessanger2Excel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AcademyMessanger2Excel>> 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.AcademyMessanger2Excel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessanger2ExcelTable> EndAcademyMessanger2ExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyMessanger2ExcelTable>(o);
+  }
+}
+
+
+static public class AcademyMessanger2ExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.AcademyMessanger2ExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyMessanger3Excel.cs

@@ -0,0 +1,133 @@
+// <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 AcademyMessanger3Excel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyMessanger3Excel GetRootAsAcademyMessanger3Excel(ByteBuffer _bb) { return GetRootAsAcademyMessanger3Excel(_bb, new AcademyMessanger3Excel()); }
+  public static AcademyMessanger3Excel GetRootAsAcademyMessanger3Excel(ByteBuffer _bb, AcademyMessanger3Excel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyMessanger3Excel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long MessageGroupId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long Id { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long CharacterId { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.AcademyMessageConditions MessageCondition { get { int o = __p.__offset(10); return o != 0 ? (SCHALE.Common.FlatData.AcademyMessageConditions)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.AcademyMessageConditions.None; } }
+  public long ConditionValue { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long PreConditionGroupId { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long PreConditionFavorScheduleId { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long FavorScheduleId { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long NextGroupId { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long FeedbackTimeMillisec { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.AcademyMessageTypes MessageType { get { int o = __p.__offset(24); return o != 0 ? (SCHALE.Common.FlatData.AcademyMessageTypes)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.AcademyMessageTypes.None; } }
+  public string ImagePath { get { int o = __p.__offset(26); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetImagePathBytes() { return __p.__vector_as_span<byte>(26, 1); }
+#else
+  public ArraySegment<byte>? GetImagePathBytes() { return __p.__vector_as_arraysegment(26); }
+#endif
+  public byte[] GetImagePathArray() { return __p.__vector_as_array<byte>(26); }
+  public string MessageKR { get { int o = __p.__offset(28); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetMessageKRBytes() { return __p.__vector_as_span<byte>(28, 1); }
+#else
+  public ArraySegment<byte>? GetMessageKRBytes() { return __p.__vector_as_arraysegment(28); }
+#endif
+  public byte[] GetMessageKRArray() { return __p.__vector_as_array<byte>(28); }
+  public string MessageJP { get { int o = __p.__offset(30); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetMessageJPBytes() { return __p.__vector_as_span<byte>(30, 1); }
+#else
+  public ArraySegment<byte>? GetMessageJPBytes() { return __p.__vector_as_arraysegment(30); }
+#endif
+  public byte[] GetMessageJPArray() { return __p.__vector_as_array<byte>(30); }
+
+  public static Offset<SCHALE.Common.FlatData.AcademyMessanger3Excel> CreateAcademyMessanger3Excel(FlatBufferBuilder builder,
+      long MessageGroupId = 0,
+      long Id = 0,
+      long CharacterId = 0,
+      SCHALE.Common.FlatData.AcademyMessageConditions MessageCondition = SCHALE.Common.FlatData.AcademyMessageConditions.None,
+      long ConditionValue = 0,
+      long PreConditionGroupId = 0,
+      long PreConditionFavorScheduleId = 0,
+      long FavorScheduleId = 0,
+      long NextGroupId = 0,
+      long FeedbackTimeMillisec = 0,
+      SCHALE.Common.FlatData.AcademyMessageTypes MessageType = SCHALE.Common.FlatData.AcademyMessageTypes.None,
+      StringOffset ImagePathOffset = default(StringOffset),
+      StringOffset MessageKROffset = default(StringOffset),
+      StringOffset MessageJPOffset = default(StringOffset)) {
+    builder.StartTable(14);
+    AcademyMessanger3Excel.AddFeedbackTimeMillisec(builder, FeedbackTimeMillisec);
+    AcademyMessanger3Excel.AddNextGroupId(builder, NextGroupId);
+    AcademyMessanger3Excel.AddFavorScheduleId(builder, FavorScheduleId);
+    AcademyMessanger3Excel.AddPreConditionFavorScheduleId(builder, PreConditionFavorScheduleId);
+    AcademyMessanger3Excel.AddPreConditionGroupId(builder, PreConditionGroupId);
+    AcademyMessanger3Excel.AddConditionValue(builder, ConditionValue);
+    AcademyMessanger3Excel.AddCharacterId(builder, CharacterId);
+    AcademyMessanger3Excel.AddId(builder, Id);
+    AcademyMessanger3Excel.AddMessageGroupId(builder, MessageGroupId);
+    AcademyMessanger3Excel.AddMessageJP(builder, MessageJPOffset);
+    AcademyMessanger3Excel.AddMessageKR(builder, MessageKROffset);
+    AcademyMessanger3Excel.AddImagePath(builder, ImagePathOffset);
+    AcademyMessanger3Excel.AddMessageType(builder, MessageType);
+    AcademyMessanger3Excel.AddMessageCondition(builder, MessageCondition);
+    return AcademyMessanger3Excel.EndAcademyMessanger3Excel(builder);
+  }
+
+  public static void StartAcademyMessanger3Excel(FlatBufferBuilder builder) { builder.StartTable(14); }
+  public static void AddMessageGroupId(FlatBufferBuilder builder, long messageGroupId) { builder.AddLong(0, messageGroupId, 0); }
+  public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(1, id, 0); }
+  public static void AddCharacterId(FlatBufferBuilder builder, long characterId) { builder.AddLong(2, characterId, 0); }
+  public static void AddMessageCondition(FlatBufferBuilder builder, SCHALE.Common.FlatData.AcademyMessageConditions messageCondition) { builder.AddInt(3, (int)messageCondition, 0); }
+  public static void AddConditionValue(FlatBufferBuilder builder, long conditionValue) { builder.AddLong(4, conditionValue, 0); }
+  public static void AddPreConditionGroupId(FlatBufferBuilder builder, long preConditionGroupId) { builder.AddLong(5, preConditionGroupId, 0); }
+  public static void AddPreConditionFavorScheduleId(FlatBufferBuilder builder, long preConditionFavorScheduleId) { builder.AddLong(6, preConditionFavorScheduleId, 0); }
+  public static void AddFavorScheduleId(FlatBufferBuilder builder, long favorScheduleId) { builder.AddLong(7, favorScheduleId, 0); }
+  public static void AddNextGroupId(FlatBufferBuilder builder, long nextGroupId) { builder.AddLong(8, nextGroupId, 0); }
+  public static void AddFeedbackTimeMillisec(FlatBufferBuilder builder, long feedbackTimeMillisec) { builder.AddLong(9, feedbackTimeMillisec, 0); }
+  public static void AddMessageType(FlatBufferBuilder builder, SCHALE.Common.FlatData.AcademyMessageTypes messageType) { builder.AddInt(10, (int)messageType, 0); }
+  public static void AddImagePath(FlatBufferBuilder builder, StringOffset imagePathOffset) { builder.AddOffset(11, imagePathOffset.Value, 0); }
+  public static void AddMessageKR(FlatBufferBuilder builder, StringOffset messageKROffset) { builder.AddOffset(12, messageKROffset.Value, 0); }
+  public static void AddMessageJP(FlatBufferBuilder builder, StringOffset messageJPOffset) { builder.AddOffset(13, messageJPOffset.Value, 0); }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessanger3Excel> EndAcademyMessanger3Excel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyMessanger3Excel>(o);
+  }
+}
+
+
+static public class AcademyMessanger3ExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*MessageGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*CharacterId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*MessageCondition*/, 4 /*SCHALE.Common.FlatData.AcademyMessageConditions*/, 4, false)
+      && verifier.VerifyField(tablePos, 12 /*ConditionValue*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 14 /*PreConditionGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 16 /*PreConditionFavorScheduleId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 18 /*FavorScheduleId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 20 /*NextGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 22 /*FeedbackTimeMillisec*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 24 /*MessageType*/, 4 /*SCHALE.Common.FlatData.AcademyMessageTypes*/, 4, false)
+      && verifier.VerifyString(tablePos, 26 /*ImagePath*/, false)
+      && verifier.VerifyString(tablePos, 28 /*MessageKR*/, false)
+      && verifier.VerifyString(tablePos, 30 /*MessageJP*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyMessanger3ExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 AcademyMessanger3ExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyMessanger3ExcelTable GetRootAsAcademyMessanger3ExcelTable(ByteBuffer _bb) { return GetRootAsAcademyMessanger3ExcelTable(_bb, new AcademyMessanger3ExcelTable()); }
+  public static AcademyMessanger3ExcelTable GetRootAsAcademyMessanger3ExcelTable(ByteBuffer _bb, AcademyMessanger3ExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyMessanger3ExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.AcademyMessanger3Excel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.AcademyMessanger3Excel?)(new SCHALE.Common.FlatData.AcademyMessanger3Excel()).__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.AcademyMessanger3ExcelTable> CreateAcademyMessanger3ExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    AcademyMessanger3ExcelTable.AddDataList(builder, DataListOffset);
+    return AcademyMessanger3ExcelTable.EndAcademyMessanger3ExcelTable(builder);
+  }
+
+  public static void StartAcademyMessanger3ExcelTable(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.AcademyMessanger3Excel>[] 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.AcademyMessanger3Excel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AcademyMessanger3Excel>> 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.AcademyMessanger3Excel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessanger3ExcelTable> EndAcademyMessanger3ExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyMessanger3ExcelTable>(o);
+  }
+}
+
+
+static public class AcademyMessanger3ExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.AcademyMessanger3ExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyMessangerExcel.cs

@@ -0,0 +1,133 @@
+// <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 AcademyMessangerExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyMessangerExcel GetRootAsAcademyMessangerExcel(ByteBuffer _bb) { return GetRootAsAcademyMessangerExcel(_bb, new AcademyMessangerExcel()); }
+  public static AcademyMessangerExcel GetRootAsAcademyMessangerExcel(ByteBuffer _bb, AcademyMessangerExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyMessangerExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long MessageGroupId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long Id { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long CharacterId { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.AcademyMessageConditions MessageCondition { get { int o = __p.__offset(10); return o != 0 ? (SCHALE.Common.FlatData.AcademyMessageConditions)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.AcademyMessageConditions.None; } }
+  public long ConditionValue { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long PreConditionGroupId { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long PreConditionFavorScheduleId { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long FavorScheduleId { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long NextGroupId { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long FeedbackTimeMillisec { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.AcademyMessageTypes MessageType { get { int o = __p.__offset(24); return o != 0 ? (SCHALE.Common.FlatData.AcademyMessageTypes)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.AcademyMessageTypes.None; } }
+  public string ImagePath { get { int o = __p.__offset(26); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetImagePathBytes() { return __p.__vector_as_span<byte>(26, 1); }
+#else
+  public ArraySegment<byte>? GetImagePathBytes() { return __p.__vector_as_arraysegment(26); }
+#endif
+  public byte[] GetImagePathArray() { return __p.__vector_as_array<byte>(26); }
+  public string MessageKR { get { int o = __p.__offset(28); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetMessageKRBytes() { return __p.__vector_as_span<byte>(28, 1); }
+#else
+  public ArraySegment<byte>? GetMessageKRBytes() { return __p.__vector_as_arraysegment(28); }
+#endif
+  public byte[] GetMessageKRArray() { return __p.__vector_as_array<byte>(28); }
+  public string MessageJP { get { int o = __p.__offset(30); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetMessageJPBytes() { return __p.__vector_as_span<byte>(30, 1); }
+#else
+  public ArraySegment<byte>? GetMessageJPBytes() { return __p.__vector_as_arraysegment(30); }
+#endif
+  public byte[] GetMessageJPArray() { return __p.__vector_as_array<byte>(30); }
+
+  public static Offset<SCHALE.Common.FlatData.AcademyMessangerExcel> CreateAcademyMessangerExcel(FlatBufferBuilder builder,
+      long MessageGroupId = 0,
+      long Id = 0,
+      long CharacterId = 0,
+      SCHALE.Common.FlatData.AcademyMessageConditions MessageCondition = SCHALE.Common.FlatData.AcademyMessageConditions.None,
+      long ConditionValue = 0,
+      long PreConditionGroupId = 0,
+      long PreConditionFavorScheduleId = 0,
+      long FavorScheduleId = 0,
+      long NextGroupId = 0,
+      long FeedbackTimeMillisec = 0,
+      SCHALE.Common.FlatData.AcademyMessageTypes MessageType = SCHALE.Common.FlatData.AcademyMessageTypes.None,
+      StringOffset ImagePathOffset = default(StringOffset),
+      StringOffset MessageKROffset = default(StringOffset),
+      StringOffset MessageJPOffset = default(StringOffset)) {
+    builder.StartTable(14);
+    AcademyMessangerExcel.AddFeedbackTimeMillisec(builder, FeedbackTimeMillisec);
+    AcademyMessangerExcel.AddNextGroupId(builder, NextGroupId);
+    AcademyMessangerExcel.AddFavorScheduleId(builder, FavorScheduleId);
+    AcademyMessangerExcel.AddPreConditionFavorScheduleId(builder, PreConditionFavorScheduleId);
+    AcademyMessangerExcel.AddPreConditionGroupId(builder, PreConditionGroupId);
+    AcademyMessangerExcel.AddConditionValue(builder, ConditionValue);
+    AcademyMessangerExcel.AddCharacterId(builder, CharacterId);
+    AcademyMessangerExcel.AddId(builder, Id);
+    AcademyMessangerExcel.AddMessageGroupId(builder, MessageGroupId);
+    AcademyMessangerExcel.AddMessageJP(builder, MessageJPOffset);
+    AcademyMessangerExcel.AddMessageKR(builder, MessageKROffset);
+    AcademyMessangerExcel.AddImagePath(builder, ImagePathOffset);
+    AcademyMessangerExcel.AddMessageType(builder, MessageType);
+    AcademyMessangerExcel.AddMessageCondition(builder, MessageCondition);
+    return AcademyMessangerExcel.EndAcademyMessangerExcel(builder);
+  }
+
+  public static void StartAcademyMessangerExcel(FlatBufferBuilder builder) { builder.StartTable(14); }
+  public static void AddMessageGroupId(FlatBufferBuilder builder, long messageGroupId) { builder.AddLong(0, messageGroupId, 0); }
+  public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(1, id, 0); }
+  public static void AddCharacterId(FlatBufferBuilder builder, long characterId) { builder.AddLong(2, characterId, 0); }
+  public static void AddMessageCondition(FlatBufferBuilder builder, SCHALE.Common.FlatData.AcademyMessageConditions messageCondition) { builder.AddInt(3, (int)messageCondition, 0); }
+  public static void AddConditionValue(FlatBufferBuilder builder, long conditionValue) { builder.AddLong(4, conditionValue, 0); }
+  public static void AddPreConditionGroupId(FlatBufferBuilder builder, long preConditionGroupId) { builder.AddLong(5, preConditionGroupId, 0); }
+  public static void AddPreConditionFavorScheduleId(FlatBufferBuilder builder, long preConditionFavorScheduleId) { builder.AddLong(6, preConditionFavorScheduleId, 0); }
+  public static void AddFavorScheduleId(FlatBufferBuilder builder, long favorScheduleId) { builder.AddLong(7, favorScheduleId, 0); }
+  public static void AddNextGroupId(FlatBufferBuilder builder, long nextGroupId) { builder.AddLong(8, nextGroupId, 0); }
+  public static void AddFeedbackTimeMillisec(FlatBufferBuilder builder, long feedbackTimeMillisec) { builder.AddLong(9, feedbackTimeMillisec, 0); }
+  public static void AddMessageType(FlatBufferBuilder builder, SCHALE.Common.FlatData.AcademyMessageTypes messageType) { builder.AddInt(10, (int)messageType, 0); }
+  public static void AddImagePath(FlatBufferBuilder builder, StringOffset imagePathOffset) { builder.AddOffset(11, imagePathOffset.Value, 0); }
+  public static void AddMessageKR(FlatBufferBuilder builder, StringOffset messageKROffset) { builder.AddOffset(12, messageKROffset.Value, 0); }
+  public static void AddMessageJP(FlatBufferBuilder builder, StringOffset messageJPOffset) { builder.AddOffset(13, messageJPOffset.Value, 0); }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessangerExcel> EndAcademyMessangerExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyMessangerExcel>(o);
+  }
+}
+
+
+static public class AcademyMessangerExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*MessageGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*CharacterId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*MessageCondition*/, 4 /*SCHALE.Common.FlatData.AcademyMessageConditions*/, 4, false)
+      && verifier.VerifyField(tablePos, 12 /*ConditionValue*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 14 /*PreConditionGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 16 /*PreConditionFavorScheduleId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 18 /*FavorScheduleId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 20 /*NextGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 22 /*FeedbackTimeMillisec*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 24 /*MessageType*/, 4 /*SCHALE.Common.FlatData.AcademyMessageTypes*/, 4, false)
+      && verifier.VerifyString(tablePos, 26 /*ImagePath*/, false)
+      && verifier.VerifyString(tablePos, 28 /*MessageKR*/, false)
+      && verifier.VerifyString(tablePos, 30 /*MessageJP*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyMessangerExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 AcademyMessangerExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyMessangerExcelTable GetRootAsAcademyMessangerExcelTable(ByteBuffer _bb) { return GetRootAsAcademyMessangerExcelTable(_bb, new AcademyMessangerExcelTable()); }
+  public static AcademyMessangerExcelTable GetRootAsAcademyMessangerExcelTable(ByteBuffer _bb, AcademyMessangerExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyMessangerExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.AcademyMessangerExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.AcademyMessangerExcel?)(new SCHALE.Common.FlatData.AcademyMessangerExcel()).__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.AcademyMessangerExcelTable> CreateAcademyMessangerExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    AcademyMessangerExcelTable.AddDataList(builder, DataListOffset);
+    return AcademyMessangerExcelTable.EndAcademyMessangerExcelTable(builder);
+  }
+
+  public static void StartAcademyMessangerExcelTable(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.AcademyMessangerExcel>[] 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.AcademyMessangerExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AcademyMessangerExcel>> 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.AcademyMessangerExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AcademyMessangerExcelTable> EndAcademyMessangerExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyMessangerExcelTable>(o);
+  }
+}
+
+
+static public class AcademyMessangerExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.AcademyMessangerExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyRewardExcel.cs

@@ -0,0 +1,253 @@
+// <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 AcademyRewardExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyRewardExcel GetRootAsAcademyRewardExcel(ByteBuffer _bb) { return GetRootAsAcademyRewardExcel(_bb, new AcademyRewardExcel()); }
+  public static AcademyRewardExcel GetRootAsAcademyRewardExcel(ByteBuffer _bb, AcademyRewardExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyRewardExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public string Location { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetLocationBytes() { return __p.__vector_as_span<byte>(4, 1); }
+#else
+  public ArraySegment<byte>? GetLocationBytes() { return __p.__vector_as_arraysegment(4); }
+#endif
+  public byte[] GetLocationArray() { return __p.__vector_as_array<byte>(4); }
+  public long ScheduleGroupId { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long OrderInGroup { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long Id { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string ProgressTexture { get { int o = __p.__offset(12); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetProgressTextureBytes() { return __p.__vector_as_span<byte>(12, 1); }
+#else
+  public ArraySegment<byte>? GetProgressTextureBytes() { return __p.__vector_as_arraysegment(12); }
+#endif
+  public byte[] GetProgressTextureArray() { return __p.__vector_as_array<byte>(12); }
+  public uint LocalizeEtcId { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public long LocationRank { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long FavorExp { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long SecretStoneAmount { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long SecretStoneProb { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long ExtraFavorExp { get { int o = __p.__offset(24); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long ExtraFavorExpProb { get { int o = __p.__offset(26); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.ParcelType ExtraRewardParcelType(int j) { int o = __p.__offset(28); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.ParcelType)0; }
+  public int ExtraRewardParcelTypeLength { get { int o = __p.__offset(28); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<SCHALE.Common.FlatData.ParcelType> GetExtraRewardParcelTypeBytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.ParcelType>(28, 4); }
+#else
+  public ArraySegment<byte>? GetExtraRewardParcelTypeBytes() { return __p.__vector_as_arraysegment(28); }
+#endif
+  public SCHALE.Common.FlatData.ParcelType[] GetExtraRewardParcelTypeArray() { int o = __p.__offset(28); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.ParcelType[] a = new SCHALE.Common.FlatData.ParcelType[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(p + i * 4); } return a; }
+  public long ExtraRewardParcelId(int j) { int o = __p.__offset(30); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int ExtraRewardParcelIdLength { get { int o = __p.__offset(30); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetExtraRewardParcelIdBytes() { return __p.__vector_as_span<long>(30, 8); }
+#else
+  public ArraySegment<byte>? GetExtraRewardParcelIdBytes() { return __p.__vector_as_arraysegment(30); }
+#endif
+  public long[] GetExtraRewardParcelIdArray() { return __p.__vector_as_array<long>(30); }
+  public long ExtraRewardAmount(int j) { int o = __p.__offset(32); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int ExtraRewardAmountLength { get { int o = __p.__offset(32); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetExtraRewardAmountBytes() { return __p.__vector_as_span<long>(32, 8); }
+#else
+  public ArraySegment<byte>? GetExtraRewardAmountBytes() { return __p.__vector_as_arraysegment(32); }
+#endif
+  public long[] GetExtraRewardAmountArray() { return __p.__vector_as_array<long>(32); }
+  public long ExtraRewardProb(int j) { int o = __p.__offset(34); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int ExtraRewardProbLength { get { int o = __p.__offset(34); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetExtraRewardProbBytes() { return __p.__vector_as_span<long>(34, 8); }
+#else
+  public ArraySegment<byte>? GetExtraRewardProbBytes() { return __p.__vector_as_arraysegment(34); }
+#endif
+  public long[] GetExtraRewardProbArray() { return __p.__vector_as_array<long>(34); }
+  public bool IsExtraRewardDisplayed(int j) { int o = __p.__offset(36); return o != 0 ? 0!=__p.bb.Get(__p.__vector(o) + j * 1) : false; }
+  public int IsExtraRewardDisplayedLength { get { int o = __p.__offset(36); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<bool> GetIsExtraRewardDisplayedBytes() { return __p.__vector_as_span<bool>(36, 1); }
+#else
+  public ArraySegment<byte>? GetIsExtraRewardDisplayedBytes() { return __p.__vector_as_arraysegment(36); }
+#endif
+  public bool[] GetIsExtraRewardDisplayedArray() { return __p.__vector_as_array<bool>(36); }
+  public SCHALE.Common.FlatData.ParcelType RewardParcelType(int j) { int o = __p.__offset(38); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.ParcelType)0; }
+  public int RewardParcelTypeLength { get { int o = __p.__offset(38); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<SCHALE.Common.FlatData.ParcelType> GetRewardParcelTypeBytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.ParcelType>(38, 4); }
+#else
+  public ArraySegment<byte>? GetRewardParcelTypeBytes() { return __p.__vector_as_arraysegment(38); }
+#endif
+  public SCHALE.Common.FlatData.ParcelType[] GetRewardParcelTypeArray() { int o = __p.__offset(38); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.ParcelType[] a = new SCHALE.Common.FlatData.ParcelType[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(p + i * 4); } return a; }
+  public long RewardParcelId(int j) { int o = __p.__offset(40); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int RewardParcelIdLength { get { int o = __p.__offset(40); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetRewardParcelIdBytes() { return __p.__vector_as_span<long>(40, 8); }
+#else
+  public ArraySegment<byte>? GetRewardParcelIdBytes() { return __p.__vector_as_arraysegment(40); }
+#endif
+  public long[] GetRewardParcelIdArray() { return __p.__vector_as_array<long>(40); }
+  public long RewardAmount(int j) { int o = __p.__offset(42); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int RewardAmountLength { get { int o = __p.__offset(42); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetRewardAmountBytes() { return __p.__vector_as_span<long>(42, 8); }
+#else
+  public ArraySegment<byte>? GetRewardAmountBytes() { return __p.__vector_as_arraysegment(42); }
+#endif
+  public long[] GetRewardAmountArray() { return __p.__vector_as_array<long>(42); }
+
+  public static Offset<SCHALE.Common.FlatData.AcademyRewardExcel> CreateAcademyRewardExcel(FlatBufferBuilder builder,
+      StringOffset LocationOffset = default(StringOffset),
+      long ScheduleGroupId = 0,
+      long OrderInGroup = 0,
+      long Id = 0,
+      StringOffset ProgressTextureOffset = default(StringOffset),
+      uint LocalizeEtcId = 0,
+      long LocationRank = 0,
+      long FavorExp = 0,
+      long SecretStoneAmount = 0,
+      long SecretStoneProb = 0,
+      long ExtraFavorExp = 0,
+      long ExtraFavorExpProb = 0,
+      VectorOffset ExtraRewardParcelTypeOffset = default(VectorOffset),
+      VectorOffset ExtraRewardParcelIdOffset = default(VectorOffset),
+      VectorOffset ExtraRewardAmountOffset = default(VectorOffset),
+      VectorOffset ExtraRewardProbOffset = default(VectorOffset),
+      VectorOffset IsExtraRewardDisplayedOffset = default(VectorOffset),
+      VectorOffset RewardParcelTypeOffset = default(VectorOffset),
+      VectorOffset RewardParcelIdOffset = default(VectorOffset),
+      VectorOffset RewardAmountOffset = default(VectorOffset)) {
+    builder.StartTable(20);
+    AcademyRewardExcel.AddExtraFavorExpProb(builder, ExtraFavorExpProb);
+    AcademyRewardExcel.AddExtraFavorExp(builder, ExtraFavorExp);
+    AcademyRewardExcel.AddSecretStoneProb(builder, SecretStoneProb);
+    AcademyRewardExcel.AddSecretStoneAmount(builder, SecretStoneAmount);
+    AcademyRewardExcel.AddFavorExp(builder, FavorExp);
+    AcademyRewardExcel.AddLocationRank(builder, LocationRank);
+    AcademyRewardExcel.AddId(builder, Id);
+    AcademyRewardExcel.AddOrderInGroup(builder, OrderInGroup);
+    AcademyRewardExcel.AddScheduleGroupId(builder, ScheduleGroupId);
+    AcademyRewardExcel.AddRewardAmount(builder, RewardAmountOffset);
+    AcademyRewardExcel.AddRewardParcelId(builder, RewardParcelIdOffset);
+    AcademyRewardExcel.AddRewardParcelType(builder, RewardParcelTypeOffset);
+    AcademyRewardExcel.AddIsExtraRewardDisplayed(builder, IsExtraRewardDisplayedOffset);
+    AcademyRewardExcel.AddExtraRewardProb(builder, ExtraRewardProbOffset);
+    AcademyRewardExcel.AddExtraRewardAmount(builder, ExtraRewardAmountOffset);
+    AcademyRewardExcel.AddExtraRewardParcelId(builder, ExtraRewardParcelIdOffset);
+    AcademyRewardExcel.AddExtraRewardParcelType(builder, ExtraRewardParcelTypeOffset);
+    AcademyRewardExcel.AddLocalizeEtcId(builder, LocalizeEtcId);
+    AcademyRewardExcel.AddProgressTexture(builder, ProgressTextureOffset);
+    AcademyRewardExcel.AddLocation(builder, LocationOffset);
+    return AcademyRewardExcel.EndAcademyRewardExcel(builder);
+  }
+
+  public static void StartAcademyRewardExcel(FlatBufferBuilder builder) { builder.StartTable(20); }
+  public static void AddLocation(FlatBufferBuilder builder, StringOffset locationOffset) { builder.AddOffset(0, locationOffset.Value, 0); }
+  public static void AddScheduleGroupId(FlatBufferBuilder builder, long scheduleGroupId) { builder.AddLong(1, scheduleGroupId, 0); }
+  public static void AddOrderInGroup(FlatBufferBuilder builder, long orderInGroup) { builder.AddLong(2, orderInGroup, 0); }
+  public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(3, id, 0); }
+  public static void AddProgressTexture(FlatBufferBuilder builder, StringOffset progressTextureOffset) { builder.AddOffset(4, progressTextureOffset.Value, 0); }
+  public static void AddLocalizeEtcId(FlatBufferBuilder builder, uint localizeEtcId) { builder.AddUint(5, localizeEtcId, 0); }
+  public static void AddLocationRank(FlatBufferBuilder builder, long locationRank) { builder.AddLong(6, locationRank, 0); }
+  public static void AddFavorExp(FlatBufferBuilder builder, long favorExp) { builder.AddLong(7, favorExp, 0); }
+  public static void AddSecretStoneAmount(FlatBufferBuilder builder, long secretStoneAmount) { builder.AddLong(8, secretStoneAmount, 0); }
+  public static void AddSecretStoneProb(FlatBufferBuilder builder, long secretStoneProb) { builder.AddLong(9, secretStoneProb, 0); }
+  public static void AddExtraFavorExp(FlatBufferBuilder builder, long extraFavorExp) { builder.AddLong(10, extraFavorExp, 0); }
+  public static void AddExtraFavorExpProb(FlatBufferBuilder builder, long extraFavorExpProb) { builder.AddLong(11, extraFavorExpProb, 0); }
+  public static void AddExtraRewardParcelType(FlatBufferBuilder builder, VectorOffset extraRewardParcelTypeOffset) { builder.AddOffset(12, extraRewardParcelTypeOffset.Value, 0); }
+  public static VectorOffset CreateExtraRewardParcelTypeVector(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt((int)data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateExtraRewardParcelTypeVectorBlock(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExtraRewardParcelTypeVectorBlock(FlatBufferBuilder builder, ArraySegment<SCHALE.Common.FlatData.ParcelType> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExtraRewardParcelTypeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<SCHALE.Common.FlatData.ParcelType>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartExtraRewardParcelTypeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddExtraRewardParcelId(FlatBufferBuilder builder, VectorOffset extraRewardParcelIdOffset) { builder.AddOffset(13, extraRewardParcelIdOffset.Value, 0); }
+  public static VectorOffset CreateExtraRewardParcelIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateExtraRewardParcelIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExtraRewardParcelIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExtraRewardParcelIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartExtraRewardParcelIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddExtraRewardAmount(FlatBufferBuilder builder, VectorOffset extraRewardAmountOffset) { builder.AddOffset(14, extraRewardAmountOffset.Value, 0); }
+  public static VectorOffset CreateExtraRewardAmountVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateExtraRewardAmountVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExtraRewardAmountVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExtraRewardAmountVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartExtraRewardAmountVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddExtraRewardProb(FlatBufferBuilder builder, VectorOffset extraRewardProbOffset) { builder.AddOffset(15, extraRewardProbOffset.Value, 0); }
+  public static VectorOffset CreateExtraRewardProbVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateExtraRewardProbVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExtraRewardProbVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExtraRewardProbVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartExtraRewardProbVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddIsExtraRewardDisplayed(FlatBufferBuilder builder, VectorOffset isExtraRewardDisplayedOffset) { builder.AddOffset(16, isExtraRewardDisplayedOffset.Value, 0); }
+  public static VectorOffset CreateIsExtraRewardDisplayedVector(FlatBufferBuilder builder, bool[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddBool(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateIsExtraRewardDisplayedVectorBlock(FlatBufferBuilder builder, bool[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateIsExtraRewardDisplayedVectorBlock(FlatBufferBuilder builder, ArraySegment<bool> data) { builder.StartVector(1, data.Count, 1); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateIsExtraRewardDisplayedVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<bool>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartIsExtraRewardDisplayedVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); }
+  public static void AddRewardParcelType(FlatBufferBuilder builder, VectorOffset rewardParcelTypeOffset) { builder.AddOffset(17, rewardParcelTypeOffset.Value, 0); }
+  public static VectorOffset CreateRewardParcelTypeVector(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt((int)data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, ArraySegment<SCHALE.Common.FlatData.ParcelType> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<SCHALE.Common.FlatData.ParcelType>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardParcelTypeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddRewardParcelId(FlatBufferBuilder builder, VectorOffset rewardParcelIdOffset) { builder.AddOffset(18, rewardParcelIdOffset.Value, 0); }
+  public static VectorOffset CreateRewardParcelIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardParcelIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddRewardAmount(FlatBufferBuilder builder, VectorOffset rewardAmountOffset) { builder.AddOffset(19, rewardAmountOffset.Value, 0); }
+  public static VectorOffset CreateRewardAmountVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateRewardAmountVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardAmountVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardAmountVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardAmountVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static Offset<SCHALE.Common.FlatData.AcademyRewardExcel> EndAcademyRewardExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyRewardExcel>(o);
+  }
+}
+
+
+static public class AcademyRewardExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyString(tablePos, 4 /*Location*/, false)
+      && verifier.VerifyField(tablePos, 6 /*ScheduleGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*OrderInGroup*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 12 /*ProgressTexture*/, false)
+      && verifier.VerifyField(tablePos, 14 /*LocalizeEtcId*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 16 /*LocationRank*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 18 /*FavorExp*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 20 /*SecretStoneAmount*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 22 /*SecretStoneProb*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 24 /*ExtraFavorExp*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 26 /*ExtraFavorExpProb*/, 8 /*long*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 28 /*ExtraRewardParcelType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 30 /*ExtraRewardParcelId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 32 /*ExtraRewardAmount*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 34 /*ExtraRewardProb*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 36 /*IsExtraRewardDisplayed*/, 1 /*bool*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 38 /*RewardParcelType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 40 /*RewardParcelId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 42 /*RewardAmount*/, 8 /*long*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyRewardExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 AcademyRewardExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyRewardExcelTable GetRootAsAcademyRewardExcelTable(ByteBuffer _bb) { return GetRootAsAcademyRewardExcelTable(_bb, new AcademyRewardExcelTable()); }
+  public static AcademyRewardExcelTable GetRootAsAcademyRewardExcelTable(ByteBuffer _bb, AcademyRewardExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyRewardExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.AcademyRewardExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.AcademyRewardExcel?)(new SCHALE.Common.FlatData.AcademyRewardExcel()).__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.AcademyRewardExcelTable> CreateAcademyRewardExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    AcademyRewardExcelTable.AddDataList(builder, DataListOffset);
+    return AcademyRewardExcelTable.EndAcademyRewardExcelTable(builder);
+  }
+
+  public static void StartAcademyRewardExcelTable(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.AcademyRewardExcel>[] 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.AcademyRewardExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AcademyRewardExcel>> 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.AcademyRewardExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AcademyRewardExcelTable> EndAcademyRewardExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyRewardExcelTable>(o);
+  }
+}
+
+
+static public class AcademyRewardExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.AcademyRewardExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyTicketExcel.cs

@@ -0,0 +1,55 @@
+// <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 AcademyTicketExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyTicketExcel GetRootAsAcademyTicketExcel(ByteBuffer _bb) { return GetRootAsAcademyTicketExcel(_bb, new AcademyTicketExcel()); }
+  public static AcademyTicketExcel GetRootAsAcademyTicketExcel(ByteBuffer _bb, AcademyTicketExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyTicketExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long LocationRankSum { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long ScheduleTicktetMax { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+
+  public static Offset<SCHALE.Common.FlatData.AcademyTicketExcel> CreateAcademyTicketExcel(FlatBufferBuilder builder,
+      long LocationRankSum = 0,
+      long ScheduleTicktetMax = 0) {
+    builder.StartTable(2);
+    AcademyTicketExcel.AddScheduleTicktetMax(builder, ScheduleTicktetMax);
+    AcademyTicketExcel.AddLocationRankSum(builder, LocationRankSum);
+    return AcademyTicketExcel.EndAcademyTicketExcel(builder);
+  }
+
+  public static void StartAcademyTicketExcel(FlatBufferBuilder builder) { builder.StartTable(2); }
+  public static void AddLocationRankSum(FlatBufferBuilder builder, long locationRankSum) { builder.AddLong(0, locationRankSum, 0); }
+  public static void AddScheduleTicktetMax(FlatBufferBuilder builder, long scheduleTicktetMax) { builder.AddLong(1, scheduleTicktetMax, 0); }
+  public static Offset<SCHALE.Common.FlatData.AcademyTicketExcel> EndAcademyTicketExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyTicketExcel>(o);
+  }
+}
+
+
+static public class AcademyTicketExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*LocationRankSum*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*ScheduleTicktetMax*/, 8 /*long*/, 8, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyTicketExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 AcademyTicketExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyTicketExcelTable GetRootAsAcademyTicketExcelTable(ByteBuffer _bb) { return GetRootAsAcademyTicketExcelTable(_bb, new AcademyTicketExcelTable()); }
+  public static AcademyTicketExcelTable GetRootAsAcademyTicketExcelTable(ByteBuffer _bb, AcademyTicketExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyTicketExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.AcademyTicketExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.AcademyTicketExcel?)(new SCHALE.Common.FlatData.AcademyTicketExcel()).__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.AcademyTicketExcelTable> CreateAcademyTicketExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    AcademyTicketExcelTable.AddDataList(builder, DataListOffset);
+    return AcademyTicketExcelTable.EndAcademyTicketExcelTable(builder);
+  }
+
+  public static void StartAcademyTicketExcelTable(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.AcademyTicketExcel>[] 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.AcademyTicketExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AcademyTicketExcel>> 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.AcademyTicketExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AcademyTicketExcelTable> EndAcademyTicketExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyTicketExcelTable>(o);
+  }
+}
+
+
+static public class AcademyTicketExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.AcademyTicketExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyZoneExcel.cs

@@ -0,0 +1,104 @@
+// <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 AcademyZoneExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyZoneExcel GetRootAsAcademyZoneExcel(ByteBuffer _bb) { return GetRootAsAcademyZoneExcel(_bb, new AcademyZoneExcel()); }
+  public static AcademyZoneExcel GetRootAsAcademyZoneExcel(ByteBuffer _bb, AcademyZoneExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyZoneExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long Id { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long LocationId { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long LocationRankForUnlock { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public uint LocalizeEtcId { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public long StudentVisitProb(int j) { int o = __p.__offset(12); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int StudentVisitProbLength { get { int o = __p.__offset(12); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetStudentVisitProbBytes() { return __p.__vector_as_span<long>(12, 8); }
+#else
+  public ArraySegment<byte>? GetStudentVisitProbBytes() { return __p.__vector_as_arraysegment(12); }
+#endif
+  public long[] GetStudentVisitProbArray() { return __p.__vector_as_array<long>(12); }
+  public long RewardGroupId { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.Tag Tags(int j) { int o = __p.__offset(16); return o != 0 ? (SCHALE.Common.FlatData.Tag)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.Tag)0; }
+  public int TagsLength { get { int o = __p.__offset(16); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<SCHALE.Common.FlatData.Tag> GetTagsBytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.Tag>(16, 4); }
+#else
+  public ArraySegment<byte>? GetTagsBytes() { return __p.__vector_as_arraysegment(16); }
+#endif
+  public SCHALE.Common.FlatData.Tag[] GetTagsArray() { int o = __p.__offset(16); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.Tag[] a = new SCHALE.Common.FlatData.Tag[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.Tag)__p.bb.GetInt(p + i * 4); } return a; }
+
+  public static Offset<SCHALE.Common.FlatData.AcademyZoneExcel> CreateAcademyZoneExcel(FlatBufferBuilder builder,
+      long Id = 0,
+      long LocationId = 0,
+      long LocationRankForUnlock = 0,
+      uint LocalizeEtcId = 0,
+      VectorOffset StudentVisitProbOffset = default(VectorOffset),
+      long RewardGroupId = 0,
+      VectorOffset TagsOffset = default(VectorOffset)) {
+    builder.StartTable(7);
+    AcademyZoneExcel.AddRewardGroupId(builder, RewardGroupId);
+    AcademyZoneExcel.AddLocationRankForUnlock(builder, LocationRankForUnlock);
+    AcademyZoneExcel.AddLocationId(builder, LocationId);
+    AcademyZoneExcel.AddId(builder, Id);
+    AcademyZoneExcel.AddTags(builder, TagsOffset);
+    AcademyZoneExcel.AddStudentVisitProb(builder, StudentVisitProbOffset);
+    AcademyZoneExcel.AddLocalizeEtcId(builder, LocalizeEtcId);
+    return AcademyZoneExcel.EndAcademyZoneExcel(builder);
+  }
+
+  public static void StartAcademyZoneExcel(FlatBufferBuilder builder) { builder.StartTable(7); }
+  public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
+  public static void AddLocationId(FlatBufferBuilder builder, long locationId) { builder.AddLong(1, locationId, 0); }
+  public static void AddLocationRankForUnlock(FlatBufferBuilder builder, long locationRankForUnlock) { builder.AddLong(2, locationRankForUnlock, 0); }
+  public static void AddLocalizeEtcId(FlatBufferBuilder builder, uint localizeEtcId) { builder.AddUint(3, localizeEtcId, 0); }
+  public static void AddStudentVisitProb(FlatBufferBuilder builder, VectorOffset studentVisitProbOffset) { builder.AddOffset(4, studentVisitProbOffset.Value, 0); }
+  public static VectorOffset CreateStudentVisitProbVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateStudentVisitProbVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateStudentVisitProbVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateStudentVisitProbVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartStudentVisitProbVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddRewardGroupId(FlatBufferBuilder builder, long rewardGroupId) { builder.AddLong(5, rewardGroupId, 0); }
+  public static void AddTags(FlatBufferBuilder builder, VectorOffset tagsOffset) { builder.AddOffset(6, tagsOffset.Value, 0); }
+  public static VectorOffset CreateTagsVector(FlatBufferBuilder builder, SCHALE.Common.FlatData.Tag[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt((int)data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateTagsVectorBlock(FlatBufferBuilder builder, SCHALE.Common.FlatData.Tag[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateTagsVectorBlock(FlatBufferBuilder builder, ArraySegment<SCHALE.Common.FlatData.Tag> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateTagsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<SCHALE.Common.FlatData.Tag>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartTagsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AcademyZoneExcel> EndAcademyZoneExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyZoneExcel>(o);
+  }
+}
+
+
+static public class AcademyZoneExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*LocationId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*LocationRankForUnlock*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*LocalizeEtcId*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyVectorOfData(tablePos, 12 /*StudentVisitProb*/, 8 /*long*/, false)
+      && verifier.VerifyField(tablePos, 14 /*RewardGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 16 /*Tags*/, 4 /*SCHALE.Common.FlatData.Tag*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AcademyZoneExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 AcademyZoneExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AcademyZoneExcelTable GetRootAsAcademyZoneExcelTable(ByteBuffer _bb) { return GetRootAsAcademyZoneExcelTable(_bb, new AcademyZoneExcelTable()); }
+  public static AcademyZoneExcelTable GetRootAsAcademyZoneExcelTable(ByteBuffer _bb, AcademyZoneExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AcademyZoneExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.AcademyZoneExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.AcademyZoneExcel?)(new SCHALE.Common.FlatData.AcademyZoneExcel()).__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.AcademyZoneExcelTable> CreateAcademyZoneExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    AcademyZoneExcelTable.AddDataList(builder, DataListOffset);
+    return AcademyZoneExcelTable.EndAcademyZoneExcelTable(builder);
+  }
+
+  public static void StartAcademyZoneExcelTable(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.AcademyZoneExcel>[] 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.AcademyZoneExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AcademyZoneExcel>> 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.AcademyZoneExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AcademyZoneExcelTable> EndAcademyZoneExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AcademyZoneExcelTable>(o);
+  }
+}
+
+
+static public class AcademyZoneExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.AcademyZoneExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AccountAchievementType.cs

@@ -0,0 +1,39 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum AccountAchievementType : int
+{
+  TotalLoginCount = 0,
+  TotalGetClearStarCount = 1,
+  TotalCharacterLevelUpCount = 2,
+  TotalCharacterSkillLevelUpCount = 3,
+  TotalClearCampaignStageCount = 4,
+  TotalClearChaserDungeonCount = 5,
+  TotalClearFindGiftAndBloodDungeonCount = 6,
+  TotalEquipmentLevelUpCount = 7,
+  TotalEquipmentTierUpCount = 8,
+  MaxComfortPoint = 9,
+  TotalGetGold = 10,
+  TotalUseGold = 11,
+  TotalJoinArenaCount = 12,
+  TotalJoinRaidCount = 13,
+  TotalClearSchoolDungeonCount = 14,
+  TotalGetWeaponCount = 15,
+  TotalWeaponLevelUpCount = 16,
+  TotalWeaponTranscendenceCount = 17,
+  KillEnemyWithDecagrammatonSPOTagCount = 18,
+  EventPoint = 19,
+  ConquestCalculateReward = 20,
+  TotalJoinEliminateRaidCount = 21,
+  Cafe2MaxComfortPoint = 22,
+  TotalRaidTicketUseCount = 23,
+  TotalEliminateTicketUseCount = 24,
+  TotalCharacterPotentialUpCount = 25,
+};
+
+
+}

SCHALE.Common/FlatData/AccountLevelExcel.cs

@@ -0,0 +1,70 @@
+// <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 AccountLevelExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AccountLevelExcel GetRootAsAccountLevelExcel(ByteBuffer _bb) { return GetRootAsAccountLevelExcel(_bb, new AccountLevelExcel()); }
+  public static AccountLevelExcel GetRootAsAccountLevelExcel(ByteBuffer _bb, AccountLevelExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AccountLevelExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long Id { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long Level { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long Exp { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long APAutoChargeMax { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public bool NeedReportEvent { get { int o = __p.__offset(12); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+
+  public static Offset<SCHALE.Common.FlatData.AccountLevelExcel> CreateAccountLevelExcel(FlatBufferBuilder builder,
+      long Id = 0,
+      long Level = 0,
+      long Exp = 0,
+      long APAutoChargeMax = 0,
+      bool NeedReportEvent = false) {
+    builder.StartTable(5);
+    AccountLevelExcel.AddAPAutoChargeMax(builder, APAutoChargeMax);
+    AccountLevelExcel.AddExp(builder, Exp);
+    AccountLevelExcel.AddLevel(builder, Level);
+    AccountLevelExcel.AddId(builder, Id);
+    AccountLevelExcel.AddNeedReportEvent(builder, NeedReportEvent);
+    return AccountLevelExcel.EndAccountLevelExcel(builder);
+  }
+
+  public static void StartAccountLevelExcel(FlatBufferBuilder builder) { builder.StartTable(5); }
+  public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
+  public static void AddLevel(FlatBufferBuilder builder, long level) { builder.AddLong(1, level, 0); }
+  public static void AddExp(FlatBufferBuilder builder, long exp) { builder.AddLong(2, exp, 0); }
+  public static void AddAPAutoChargeMax(FlatBufferBuilder builder, long aPAutoChargeMax) { builder.AddLong(3, aPAutoChargeMax, 0); }
+  public static void AddNeedReportEvent(FlatBufferBuilder builder, bool needReportEvent) { builder.AddBool(4, needReportEvent, false); }
+  public static Offset<SCHALE.Common.FlatData.AccountLevelExcel> EndAccountLevelExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AccountLevelExcel>(o);
+  }
+}
+
+
+static public class AccountLevelExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*Level*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*Exp*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*APAutoChargeMax*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 12 /*NeedReportEvent*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AccountLevelExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 AccountLevelExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AccountLevelExcelTable GetRootAsAccountLevelExcelTable(ByteBuffer _bb) { return GetRootAsAccountLevelExcelTable(_bb, new AccountLevelExcelTable()); }
+  public static AccountLevelExcelTable GetRootAsAccountLevelExcelTable(ByteBuffer _bb, AccountLevelExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AccountLevelExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.AccountLevelExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.AccountLevelExcel?)(new SCHALE.Common.FlatData.AccountLevelExcel()).__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.AccountLevelExcelTable> CreateAccountLevelExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    AccountLevelExcelTable.AddDataList(builder, DataListOffset);
+    return AccountLevelExcelTable.EndAccountLevelExcelTable(builder);
+  }
+
+  public static void StartAccountLevelExcelTable(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.AccountLevelExcel>[] 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.AccountLevelExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AccountLevelExcel>> 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.AccountLevelExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AccountLevelExcelTable> EndAccountLevelExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AccountLevelExcelTable>(o);
+  }
+}
+
+
+static public class AccountLevelExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.AccountLevelExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AccountState.cs

@@ -0,0 +1,18 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum AccountState : int
+{
+  WaitingSignIn = 0,
+  Normal = 1,
+  Dormant = 2,
+  Comeback = 3,
+  Newbie = 4,
+};
+
+
+}

SCHALE.Common/FlatData/ActionType.cs

@@ -0,0 +1,16 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum ActionType : int
+{
+  Crush = 0,
+  Courage = 1,
+  Tactic = 2,
+};
+
+
+}

SCHALE.Common/FlatData/AimIKType.cs

@@ -0,0 +1,21 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum AimIKType : int
+{
+  None = 0,
+  OneHandRight = 1,
+  OneHandLeft = 2,
+  TwoHandRight = 3,
+  TwoHandLeft = 4,
+  Tripod = 5,
+  Dual = 6,
+  Max = 7,
+};
+
+
+}

SCHALE.Common/FlatData/AniEventData.cs

@@ -0,0 +1,82 @@
+// <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 AniEventData : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AniEventData GetRootAsAniEventData(ByteBuffer _bb) { return GetRootAsAniEventData(_bb, new AniEventData()); }
+  public static AniEventData GetRootAsAniEventData(ByteBuffer _bb, AniEventData obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AniEventData __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public string Name { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetNameBytes() { return __p.__vector_as_span<byte>(4, 1); }
+#else
+  public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(4); }
+#endif
+  public byte[] GetNameArray() { return __p.__vector_as_array<byte>(4); }
+  public float Time { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public int IntParam { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public float FloatParam { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public string StringParam { get { int o = __p.__offset(12); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetStringParamBytes() { return __p.__vector_as_span<byte>(12, 1); }
+#else
+  public ArraySegment<byte>? GetStringParamBytes() { return __p.__vector_as_arraysegment(12); }
+#endif
+  public byte[] GetStringParamArray() { return __p.__vector_as_array<byte>(12); }
+
+  public static Offset<SCHALE.Common.FlatData.AniEventData> CreateAniEventData(FlatBufferBuilder builder,
+      StringOffset NameOffset = default(StringOffset),
+      float Time = 0.0f,
+      int IntParam = 0,
+      float FloatParam = 0.0f,
+      StringOffset StringParamOffset = default(StringOffset)) {
+    builder.StartTable(5);
+    AniEventData.AddStringParam(builder, StringParamOffset);
+    AniEventData.AddFloatParam(builder, FloatParam);
+    AniEventData.AddIntParam(builder, IntParam);
+    AniEventData.AddTime(builder, Time);
+    AniEventData.AddName(builder, NameOffset);
+    return AniEventData.EndAniEventData(builder);
+  }
+
+  public static void StartAniEventData(FlatBufferBuilder builder) { builder.StartTable(5); }
+  public static void AddName(FlatBufferBuilder builder, StringOffset nameOffset) { builder.AddOffset(0, nameOffset.Value, 0); }
+  public static void AddTime(FlatBufferBuilder builder, float time) { builder.AddFloat(1, time, 0.0f); }
+  public static void AddIntParam(FlatBufferBuilder builder, int intParam) { builder.AddInt(2, intParam, 0); }
+  public static void AddFloatParam(FlatBufferBuilder builder, float floatParam) { builder.AddFloat(3, floatParam, 0.0f); }
+  public static void AddStringParam(FlatBufferBuilder builder, StringOffset stringParamOffset) { builder.AddOffset(4, stringParamOffset.Value, 0); }
+  public static Offset<SCHALE.Common.FlatData.AniEventData> EndAniEventData(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AniEventData>(o);
+  }
+}
+
+
+static public class AniEventDataVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyString(tablePos, 4 /*Name*/, false)
+      && verifier.VerifyField(tablePos, 6 /*Time*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*IntParam*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*FloatParam*/, 4 /*float*/, 4, false)
+      && verifier.VerifyString(tablePos, 12 /*StringParam*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AniStateData.cs

@@ -0,0 +1,147 @@
+// <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 AniStateData : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AniStateData GetRootAsAniStateData(ByteBuffer _bb) { return GetRootAsAniStateData(_bb, new AniStateData()); }
+  public static AniStateData GetRootAsAniStateData(ByteBuffer _bb, AniStateData obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AniStateData __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public string StateName { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetStateNameBytes() { return __p.__vector_as_span<byte>(4, 1); }
+#else
+  public ArraySegment<byte>? GetStateNameBytes() { return __p.__vector_as_arraysegment(4); }
+#endif
+  public byte[] GetStateNameArray() { return __p.__vector_as_array<byte>(4); }
+  public string StatePrefix { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetStatePrefixBytes() { return __p.__vector_as_span<byte>(6, 1); }
+#else
+  public ArraySegment<byte>? GetStatePrefixBytes() { return __p.__vector_as_arraysegment(6); }
+#endif
+  public byte[] GetStatePrefixArray() { return __p.__vector_as_array<byte>(6); }
+  public string StateNameWithPrefix { get { int o = __p.__offset(8); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetStateNameWithPrefixBytes() { return __p.__vector_as_span<byte>(8, 1); }
+#else
+  public ArraySegment<byte>? GetStateNameWithPrefixBytes() { return __p.__vector_as_arraysegment(8); }
+#endif
+  public byte[] GetStateNameWithPrefixArray() { return __p.__vector_as_array<byte>(8); }
+  public string Tag { get { int o = __p.__offset(10); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetTagBytes() { return __p.__vector_as_span<byte>(10, 1); }
+#else
+  public ArraySegment<byte>? GetTagBytes() { return __p.__vector_as_arraysegment(10); }
+#endif
+  public byte[] GetTagArray() { return __p.__vector_as_array<byte>(10); }
+  public string SpeedParameterName { get { int o = __p.__offset(12); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetSpeedParameterNameBytes() { return __p.__vector_as_span<byte>(12, 1); }
+#else
+  public ArraySegment<byte>? GetSpeedParameterNameBytes() { return __p.__vector_as_arraysegment(12); }
+#endif
+  public byte[] GetSpeedParameterNameArray() { return __p.__vector_as_array<byte>(12); }
+  public float SpeedParamter { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public float StateSpeed { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public string ClipName { get { int o = __p.__offset(18); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetClipNameBytes() { return __p.__vector_as_span<byte>(18, 1); }
+#else
+  public ArraySegment<byte>? GetClipNameBytes() { return __p.__vector_as_arraysegment(18); }
+#endif
+  public byte[] GetClipNameArray() { return __p.__vector_as_array<byte>(18); }
+  public float Length { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public float FrameRate { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public bool IsLooping { get { int o = __p.__offset(24); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public SCHALE.Common.FlatData.AniEventData? Events(int j) { int o = __p.__offset(26); return o != 0 ? (SCHALE.Common.FlatData.AniEventData?)(new SCHALE.Common.FlatData.AniEventData()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int EventsLength { get { int o = __p.__offset(26); return o != 0 ? __p.__vector_len(o) : 0; } }
+
+  public static Offset<SCHALE.Common.FlatData.AniStateData> CreateAniStateData(FlatBufferBuilder builder,
+      StringOffset StateNameOffset = default(StringOffset),
+      StringOffset StatePrefixOffset = default(StringOffset),
+      StringOffset StateNameWithPrefixOffset = default(StringOffset),
+      StringOffset TagOffset = default(StringOffset),
+      StringOffset SpeedParameterNameOffset = default(StringOffset),
+      float SpeedParamter = 0.0f,
+      float StateSpeed = 0.0f,
+      StringOffset ClipNameOffset = default(StringOffset),
+      float Length = 0.0f,
+      float FrameRate = 0.0f,
+      bool IsLooping = false,
+      VectorOffset EventsOffset = default(VectorOffset)) {
+    builder.StartTable(12);
+    AniStateData.AddEvents(builder, EventsOffset);
+    AniStateData.AddFrameRate(builder, FrameRate);
+    AniStateData.AddLength(builder, Length);
+    AniStateData.AddClipName(builder, ClipNameOffset);
+    AniStateData.AddStateSpeed(builder, StateSpeed);
+    AniStateData.AddSpeedParamter(builder, SpeedParamter);
+    AniStateData.AddSpeedParameterName(builder, SpeedParameterNameOffset);
+    AniStateData.AddTag(builder, TagOffset);
+    AniStateData.AddStateNameWithPrefix(builder, StateNameWithPrefixOffset);
+    AniStateData.AddStatePrefix(builder, StatePrefixOffset);
+    AniStateData.AddStateName(builder, StateNameOffset);
+    AniStateData.AddIsLooping(builder, IsLooping);
+    return AniStateData.EndAniStateData(builder);
+  }
+
+  public static void StartAniStateData(FlatBufferBuilder builder) { builder.StartTable(12); }
+  public static void AddStateName(FlatBufferBuilder builder, StringOffset stateNameOffset) { builder.AddOffset(0, stateNameOffset.Value, 0); }
+  public static void AddStatePrefix(FlatBufferBuilder builder, StringOffset statePrefixOffset) { builder.AddOffset(1, statePrefixOffset.Value, 0); }
+  public static void AddStateNameWithPrefix(FlatBufferBuilder builder, StringOffset stateNameWithPrefixOffset) { builder.AddOffset(2, stateNameWithPrefixOffset.Value, 0); }
+  public static void AddTag(FlatBufferBuilder builder, StringOffset tagOffset) { builder.AddOffset(3, tagOffset.Value, 0); }
+  public static void AddSpeedParameterName(FlatBufferBuilder builder, StringOffset speedParameterNameOffset) { builder.AddOffset(4, speedParameterNameOffset.Value, 0); }
+  public static void AddSpeedParamter(FlatBufferBuilder builder, float speedParamter) { builder.AddFloat(5, speedParamter, 0.0f); }
+  public static void AddStateSpeed(FlatBufferBuilder builder, float stateSpeed) { builder.AddFloat(6, stateSpeed, 0.0f); }
+  public static void AddClipName(FlatBufferBuilder builder, StringOffset clipNameOffset) { builder.AddOffset(7, clipNameOffset.Value, 0); }
+  public static void AddLength(FlatBufferBuilder builder, float length) { builder.AddFloat(8, length, 0.0f); }
+  public static void AddFrameRate(FlatBufferBuilder builder, float frameRate) { builder.AddFloat(9, frameRate, 0.0f); }
+  public static void AddIsLooping(FlatBufferBuilder builder, bool isLooping) { builder.AddBool(10, isLooping, false); }
+  public static void AddEvents(FlatBufferBuilder builder, VectorOffset eventsOffset) { builder.AddOffset(11, eventsOffset.Value, 0); }
+  public static VectorOffset CreateEventsVector(FlatBufferBuilder builder, Offset<SCHALE.Common.FlatData.AniEventData>[] 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 CreateEventsVectorBlock(FlatBufferBuilder builder, Offset<SCHALE.Common.FlatData.AniEventData>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateEventsVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AniEventData>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateEventsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<SCHALE.Common.FlatData.AniEventData>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartEventsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AniStateData> EndAniStateData(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AniStateData>(o);
+  }
+}
+
+
+static public class AniStateDataVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyString(tablePos, 4 /*StateName*/, false)
+      && verifier.VerifyString(tablePos, 6 /*StatePrefix*/, false)
+      && verifier.VerifyString(tablePos, 8 /*StateNameWithPrefix*/, false)
+      && verifier.VerifyString(tablePos, 10 /*Tag*/, false)
+      && verifier.VerifyString(tablePos, 12 /*SpeedParameterName*/, false)
+      && verifier.VerifyField(tablePos, 14 /*SpeedParamter*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 16 /*StateSpeed*/, 4 /*float*/, 4, false)
+      && verifier.VerifyString(tablePos, 18 /*ClipName*/, false)
+      && verifier.VerifyField(tablePos, 20 /*Length*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 22 /*FrameRate*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 24 /*IsLooping*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyVectorOfTables(tablePos, 26 /*Events*/, SCHALE.Common.FlatData.AniEventDataVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AnimationBlendTable.cs

@@ -0,0 +1,56 @@
+// <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 AnimationBlendTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AnimationBlendTable GetRootAsAnimationBlendTable(ByteBuffer _bb) { return GetRootAsAnimationBlendTable(_bb, new AnimationBlendTable()); }
+  public static AnimationBlendTable GetRootAsAnimationBlendTable(ByteBuffer _bb, AnimationBlendTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AnimationBlendTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.BlendData? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.BlendData?)(new SCHALE.Common.FlatData.BlendData()).__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.AnimationBlendTable> CreateAnimationBlendTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    AnimationBlendTable.AddDataList(builder, DataListOffset);
+    return AnimationBlendTable.EndAnimationBlendTable(builder);
+  }
+
+  public static void StartAnimationBlendTable(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.BlendData>[] 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.BlendData>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.BlendData>> 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.BlendData>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AnimationBlendTable> EndAnimationBlendTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AnimationBlendTable>(o);
+  }
+}
+
+
+static public class AnimationBlendTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.BlendDataVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AnimatorData.cs

@@ -0,0 +1,78 @@
+// <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 AnimatorData : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AnimatorData GetRootAsAnimatorData(ByteBuffer _bb) { return GetRootAsAnimatorData(_bb, new AnimatorData()); }
+  public static AnimatorData GetRootAsAnimatorData(ByteBuffer _bb, AnimatorData obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AnimatorData __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public string DefaultStateName { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetDefaultStateNameBytes() { return __p.__vector_as_span<byte>(4, 1); }
+#else
+  public ArraySegment<byte>? GetDefaultStateNameBytes() { return __p.__vector_as_arraysegment(4); }
+#endif
+  public byte[] GetDefaultStateNameArray() { return __p.__vector_as_array<byte>(4); }
+  public string Name { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetNameBytes() { return __p.__vector_as_span<byte>(6, 1); }
+#else
+  public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(6); }
+#endif
+  public byte[] GetNameArray() { return __p.__vector_as_array<byte>(6); }
+  public SCHALE.Common.FlatData.AniStateData? DataList(int j) { int o = __p.__offset(8); return o != 0 ? (SCHALE.Common.FlatData.AniStateData?)(new SCHALE.Common.FlatData.AniStateData()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int DataListLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
+
+  public static Offset<SCHALE.Common.FlatData.AnimatorData> CreateAnimatorData(FlatBufferBuilder builder,
+      StringOffset DefaultStateNameOffset = default(StringOffset),
+      StringOffset NameOffset = default(StringOffset),
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(3);
+    AnimatorData.AddDataList(builder, DataListOffset);
+    AnimatorData.AddName(builder, NameOffset);
+    AnimatorData.AddDefaultStateName(builder, DefaultStateNameOffset);
+    return AnimatorData.EndAnimatorData(builder);
+  }
+
+  public static void StartAnimatorData(FlatBufferBuilder builder) { builder.StartTable(3); }
+  public static void AddDefaultStateName(FlatBufferBuilder builder, StringOffset defaultStateNameOffset) { builder.AddOffset(0, defaultStateNameOffset.Value, 0); }
+  public static void AddName(FlatBufferBuilder builder, StringOffset nameOffset) { builder.AddOffset(1, nameOffset.Value, 0); }
+  public static void AddDataList(FlatBufferBuilder builder, VectorOffset dataListOffset) { builder.AddOffset(2, dataListOffset.Value, 0); }
+  public static VectorOffset CreateDataListVector(FlatBufferBuilder builder, Offset<SCHALE.Common.FlatData.AniStateData>[] 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.AniStateData>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AniStateData>> 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.AniStateData>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AnimatorData> EndAnimatorData(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AnimatorData>(o);
+  }
+}
+
+
+static public class AnimatorDataVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyString(tablePos, 4 /*DefaultStateName*/, false)
+      && verifier.VerifyString(tablePos, 6 /*Name*/, false)
+      && verifier.VerifyVectorOfTables(tablePos, 8 /*DataList*/, SCHALE.Common.FlatData.AniStateDataVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AnimatorDataTable.cs

@@ -0,0 +1,56 @@
+// <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 AnimatorDataTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AnimatorDataTable GetRootAsAnimatorDataTable(ByteBuffer _bb) { return GetRootAsAnimatorDataTable(_bb, new AnimatorDataTable()); }
+  public static AnimatorDataTable GetRootAsAnimatorDataTable(ByteBuffer _bb, AnimatorDataTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AnimatorDataTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.AnimatorData? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.AnimatorData?)(new SCHALE.Common.FlatData.AnimatorData()).__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.AnimatorDataTable> CreateAnimatorDataTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    AnimatorDataTable.AddDataList(builder, DataListOffset);
+    return AnimatorDataTable.EndAnimatorDataTable(builder);
+  }
+
+  public static void StartAnimatorDataTable(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.AnimatorData>[] 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.AnimatorData>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AnimatorData>> 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.AnimatorData>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AnimatorDataTable> EndAnimatorDataTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AnimatorDataTable>(o);
+  }
+}
+
+
+static public class AnimatorDataTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.AnimatorDataVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/Anniversary.cs

@@ -0,0 +1,16 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum Anniversary : int
+{
+  None = 0,
+  UserBDay = 1,
+  StudentBDay = 2,
+};
+
+
+}

SCHALE.Common/FlatData/ArenaLevelSectionExcel.cs

@@ -0,0 +1,65 @@
+// <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 ArenaLevelSectionExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static ArenaLevelSectionExcel GetRootAsArenaLevelSectionExcel(ByteBuffer _bb) { return GetRootAsArenaLevelSectionExcel(_bb, new ArenaLevelSectionExcel()); }
+  public static ArenaLevelSectionExcel GetRootAsArenaLevelSectionExcel(ByteBuffer _bb, ArenaLevelSectionExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public ArenaLevelSectionExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long ArenaSeasonId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long StartLevel { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long LastLevel { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long UserCount { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+
+  public static Offset<SCHALE.Common.FlatData.ArenaLevelSectionExcel> CreateArenaLevelSectionExcel(FlatBufferBuilder builder,
+      long ArenaSeasonId = 0,
+      long StartLevel = 0,
+      long LastLevel = 0,
+      long UserCount = 0) {
+    builder.StartTable(4);
+    ArenaLevelSectionExcel.AddUserCount(builder, UserCount);
+    ArenaLevelSectionExcel.AddLastLevel(builder, LastLevel);
+    ArenaLevelSectionExcel.AddStartLevel(builder, StartLevel);
+    ArenaLevelSectionExcel.AddArenaSeasonId(builder, ArenaSeasonId);
+    return ArenaLevelSectionExcel.EndArenaLevelSectionExcel(builder);
+  }
+
+  public static void StartArenaLevelSectionExcel(FlatBufferBuilder builder) { builder.StartTable(4); }
+  public static void AddArenaSeasonId(FlatBufferBuilder builder, long arenaSeasonId) { builder.AddLong(0, arenaSeasonId, 0); }
+  public static void AddStartLevel(FlatBufferBuilder builder, long startLevel) { builder.AddLong(1, startLevel, 0); }
+  public static void AddLastLevel(FlatBufferBuilder builder, long lastLevel) { builder.AddLong(2, lastLevel, 0); }
+  public static void AddUserCount(FlatBufferBuilder builder, long userCount) { builder.AddLong(3, userCount, 0); }
+  public static Offset<SCHALE.Common.FlatData.ArenaLevelSectionExcel> EndArenaLevelSectionExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.ArenaLevelSectionExcel>(o);
+  }
+}
+
+
+static public class ArenaLevelSectionExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*ArenaSeasonId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*StartLevel*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*LastLevel*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*UserCount*/, 8 /*long*/, 8, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/ArenaLevelSectionExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 ArenaLevelSectionExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static ArenaLevelSectionExcelTable GetRootAsArenaLevelSectionExcelTable(ByteBuffer _bb) { return GetRootAsArenaLevelSectionExcelTable(_bb, new ArenaLevelSectionExcelTable()); }
+  public static ArenaLevelSectionExcelTable GetRootAsArenaLevelSectionExcelTable(ByteBuffer _bb, ArenaLevelSectionExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public ArenaLevelSectionExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.ArenaLevelSectionExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.ArenaLevelSectionExcel?)(new SCHALE.Common.FlatData.ArenaLevelSectionExcel()).__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.ArenaLevelSectionExcelTable> CreateArenaLevelSectionExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    ArenaLevelSectionExcelTable.AddDataList(builder, DataListOffset);
+    return ArenaLevelSectionExcelTable.EndArenaLevelSectionExcelTable(builder);
+  }
+
+  public static void StartArenaLevelSectionExcelTable(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.ArenaLevelSectionExcel>[] 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.ArenaLevelSectionExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.ArenaLevelSectionExcel>> 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.ArenaLevelSectionExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.ArenaLevelSectionExcelTable> EndArenaLevelSectionExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.ArenaLevelSectionExcelTable>(o);
+  }
+}
+
+
+static public class ArenaLevelSectionExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.ArenaLevelSectionExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/ArenaMapExcel.cs

@@ -0,0 +1,108 @@
+// <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 ArenaMapExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static ArenaMapExcel GetRootAsArenaMapExcel(ByteBuffer _bb) { return GetRootAsArenaMapExcel(_bb, new ArenaMapExcel()); }
+  public static ArenaMapExcel GetRootAsArenaMapExcel(ByteBuffer _bb, ArenaMapExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public ArenaMapExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long UniqueId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long TerrainType { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string TerrainTypeLocalizeKey { get { int o = __p.__offset(8); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetTerrainTypeLocalizeKeyBytes() { return __p.__vector_as_span<byte>(8, 1); }
+#else
+  public ArraySegment<byte>? GetTerrainTypeLocalizeKeyBytes() { return __p.__vector_as_arraysegment(8); }
+#endif
+  public byte[] GetTerrainTypeLocalizeKeyArray() { return __p.__vector_as_array<byte>(8); }
+  public string ImagePath { get { int o = __p.__offset(10); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetImagePathBytes() { return __p.__vector_as_span<byte>(10, 1); }
+#else
+  public ArraySegment<byte>? GetImagePathBytes() { return __p.__vector_as_arraysegment(10); }
+#endif
+  public byte[] GetImagePathArray() { return __p.__vector_as_array<byte>(10); }
+  public long GroundGroupId { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string GroundGroupNameLocalizeKey { get { int o = __p.__offset(14); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetGroundGroupNameLocalizeKeyBytes() { return __p.__vector_as_span<byte>(14, 1); }
+#else
+  public ArraySegment<byte>? GetGroundGroupNameLocalizeKeyBytes() { return __p.__vector_as_arraysegment(14); }
+#endif
+  public byte[] GetGroundGroupNameLocalizeKeyArray() { return __p.__vector_as_array<byte>(14); }
+  public long StartRank { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long EndRank { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long GroundId { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+
+  public static Offset<SCHALE.Common.FlatData.ArenaMapExcel> CreateArenaMapExcel(FlatBufferBuilder builder,
+      long UniqueId = 0,
+      long TerrainType = 0,
+      StringOffset TerrainTypeLocalizeKeyOffset = default(StringOffset),
+      StringOffset ImagePathOffset = default(StringOffset),
+      long GroundGroupId = 0,
+      StringOffset GroundGroupNameLocalizeKeyOffset = default(StringOffset),
+      long StartRank = 0,
+      long EndRank = 0,
+      long GroundId = 0) {
+    builder.StartTable(9);
+    ArenaMapExcel.AddGroundId(builder, GroundId);
+    ArenaMapExcel.AddEndRank(builder, EndRank);
+    ArenaMapExcel.AddStartRank(builder, StartRank);
+    ArenaMapExcel.AddGroundGroupId(builder, GroundGroupId);
+    ArenaMapExcel.AddTerrainType(builder, TerrainType);
+    ArenaMapExcel.AddUniqueId(builder, UniqueId);
+    ArenaMapExcel.AddGroundGroupNameLocalizeKey(builder, GroundGroupNameLocalizeKeyOffset);
+    ArenaMapExcel.AddImagePath(builder, ImagePathOffset);
+    ArenaMapExcel.AddTerrainTypeLocalizeKey(builder, TerrainTypeLocalizeKeyOffset);
+    return ArenaMapExcel.EndArenaMapExcel(builder);
+  }
+
+  public static void StartArenaMapExcel(FlatBufferBuilder builder) { builder.StartTable(9); }
+  public static void AddUniqueId(FlatBufferBuilder builder, long uniqueId) { builder.AddLong(0, uniqueId, 0); }
+  public static void AddTerrainType(FlatBufferBuilder builder, long terrainType) { builder.AddLong(1, terrainType, 0); }
+  public static void AddTerrainTypeLocalizeKey(FlatBufferBuilder builder, StringOffset terrainTypeLocalizeKeyOffset) { builder.AddOffset(2, terrainTypeLocalizeKeyOffset.Value, 0); }
+  public static void AddImagePath(FlatBufferBuilder builder, StringOffset imagePathOffset) { builder.AddOffset(3, imagePathOffset.Value, 0); }
+  public static void AddGroundGroupId(FlatBufferBuilder builder, long groundGroupId) { builder.AddLong(4, groundGroupId, 0); }
+  public static void AddGroundGroupNameLocalizeKey(FlatBufferBuilder builder, StringOffset groundGroupNameLocalizeKeyOffset) { builder.AddOffset(5, groundGroupNameLocalizeKeyOffset.Value, 0); }
+  public static void AddStartRank(FlatBufferBuilder builder, long startRank) { builder.AddLong(6, startRank, 0); }
+  public static void AddEndRank(FlatBufferBuilder builder, long endRank) { builder.AddLong(7, endRank, 0); }
+  public static void AddGroundId(FlatBufferBuilder builder, long groundId) { builder.AddLong(8, groundId, 0); }
+  public static Offset<SCHALE.Common.FlatData.ArenaMapExcel> EndArenaMapExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.ArenaMapExcel>(o);
+  }
+}
+
+
+static public class ArenaMapExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*UniqueId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*TerrainType*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 8 /*TerrainTypeLocalizeKey*/, false)
+      && verifier.VerifyString(tablePos, 10 /*ImagePath*/, false)
+      && verifier.VerifyField(tablePos, 12 /*GroundGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 14 /*GroundGroupNameLocalizeKey*/, false)
+      && verifier.VerifyField(tablePos, 16 /*StartRank*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 18 /*EndRank*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 20 /*GroundId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/ArenaMapExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 ArenaMapExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static ArenaMapExcelTable GetRootAsArenaMapExcelTable(ByteBuffer _bb) { return GetRootAsArenaMapExcelTable(_bb, new ArenaMapExcelTable()); }
+  public static ArenaMapExcelTable GetRootAsArenaMapExcelTable(ByteBuffer _bb, ArenaMapExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public ArenaMapExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.ArenaMapExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.ArenaMapExcel?)(new SCHALE.Common.FlatData.ArenaMapExcel()).__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.ArenaMapExcelTable> CreateArenaMapExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    ArenaMapExcelTable.AddDataList(builder, DataListOffset);
+    return ArenaMapExcelTable.EndArenaMapExcelTable(builder);
+  }
+
+  public static void StartArenaMapExcelTable(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.ArenaMapExcel>[] 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.ArenaMapExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.ArenaMapExcel>> 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.ArenaMapExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.ArenaMapExcelTable> EndArenaMapExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.ArenaMapExcelTable>(o);
+  }
+}
+
+
+static public class ArenaMapExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.ArenaMapExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/ArenaNPCExcel.cs

@@ -0,0 +1,148 @@
+// <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 ArenaNPCExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static ArenaNPCExcel GetRootAsArenaNPCExcel(ByteBuffer _bb) { return GetRootAsArenaNPCExcel(_bb, new ArenaNPCExcel()); }
+  public static ArenaNPCExcel GetRootAsArenaNPCExcel(ByteBuffer _bb, ArenaNPCExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public ArenaNPCExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long UniqueId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long Rank { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long NPCAccountLevel { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long NPCLevel { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long NPCLevelDeviation { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long NPCStarGrade { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public bool UseTSS { get { int o = __p.__offset(16); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public SCHALE.Common.FlatData.Rarity ExceptionCharacterRarities(int j) { int o = __p.__offset(18); return o != 0 ? (SCHALE.Common.FlatData.Rarity)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.Rarity)0; }
+  public int ExceptionCharacterRaritiesLength { get { int o = __p.__offset(18); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<SCHALE.Common.FlatData.Rarity> GetExceptionCharacterRaritiesBytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.Rarity>(18, 4); }
+#else
+  public ArraySegment<byte>? GetExceptionCharacterRaritiesBytes() { return __p.__vector_as_arraysegment(18); }
+#endif
+  public SCHALE.Common.FlatData.Rarity[] GetExceptionCharacterRaritiesArray() { int o = __p.__offset(18); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.Rarity[] a = new SCHALE.Common.FlatData.Rarity[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.Rarity)__p.bb.GetInt(p + i * 4); } return a; }
+  public long ExceptionMainCharacterIds(int j) { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int ExceptionMainCharacterIdsLength { get { int o = __p.__offset(20); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetExceptionMainCharacterIdsBytes() { return __p.__vector_as_span<long>(20, 8); }
+#else
+  public ArraySegment<byte>? GetExceptionMainCharacterIdsBytes() { return __p.__vector_as_arraysegment(20); }
+#endif
+  public long[] GetExceptionMainCharacterIdsArray() { return __p.__vector_as_array<long>(20); }
+  public long ExceptionSupportCharacterIds(int j) { int o = __p.__offset(22); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int ExceptionSupportCharacterIdsLength { get { int o = __p.__offset(22); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetExceptionSupportCharacterIdsBytes() { return __p.__vector_as_span<long>(22, 8); }
+#else
+  public ArraySegment<byte>? GetExceptionSupportCharacterIdsBytes() { return __p.__vector_as_arraysegment(22); }
+#endif
+  public long[] GetExceptionSupportCharacterIdsArray() { return __p.__vector_as_array<long>(22); }
+  public long ExceptionTSSIds(int j) { int o = __p.__offset(24); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int ExceptionTSSIdsLength { get { int o = __p.__offset(24); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetExceptionTSSIdsBytes() { return __p.__vector_as_span<long>(24, 8); }
+#else
+  public ArraySegment<byte>? GetExceptionTSSIdsBytes() { return __p.__vector_as_arraysegment(24); }
+#endif
+  public long[] GetExceptionTSSIdsArray() { return __p.__vector_as_array<long>(24); }
+
+  public static Offset<SCHALE.Common.FlatData.ArenaNPCExcel> CreateArenaNPCExcel(FlatBufferBuilder builder,
+      long UniqueId = 0,
+      long Rank = 0,
+      long NPCAccountLevel = 0,
+      long NPCLevel = 0,
+      long NPCLevelDeviation = 0,
+      long NPCStarGrade = 0,
+      bool UseTSS = false,
+      VectorOffset ExceptionCharacterRaritiesOffset = default(VectorOffset),
+      VectorOffset ExceptionMainCharacterIdsOffset = default(VectorOffset),
+      VectorOffset ExceptionSupportCharacterIdsOffset = default(VectorOffset),
+      VectorOffset ExceptionTSSIdsOffset = default(VectorOffset)) {
+    builder.StartTable(11);
+    ArenaNPCExcel.AddNPCStarGrade(builder, NPCStarGrade);
+    ArenaNPCExcel.AddNPCLevelDeviation(builder, NPCLevelDeviation);
+    ArenaNPCExcel.AddNPCLevel(builder, NPCLevel);
+    ArenaNPCExcel.AddNPCAccountLevel(builder, NPCAccountLevel);
+    ArenaNPCExcel.AddRank(builder, Rank);
+    ArenaNPCExcel.AddUniqueId(builder, UniqueId);
+    ArenaNPCExcel.AddExceptionTSSIds(builder, ExceptionTSSIdsOffset);
+    ArenaNPCExcel.AddExceptionSupportCharacterIds(builder, ExceptionSupportCharacterIdsOffset);
+    ArenaNPCExcel.AddExceptionMainCharacterIds(builder, ExceptionMainCharacterIdsOffset);
+    ArenaNPCExcel.AddExceptionCharacterRarities(builder, ExceptionCharacterRaritiesOffset);
+    ArenaNPCExcel.AddUseTSS(builder, UseTSS);
+    return ArenaNPCExcel.EndArenaNPCExcel(builder);
+  }
+
+  public static void StartArenaNPCExcel(FlatBufferBuilder builder) { builder.StartTable(11); }
+  public static void AddUniqueId(FlatBufferBuilder builder, long uniqueId) { builder.AddLong(0, uniqueId, 0); }
+  public static void AddRank(FlatBufferBuilder builder, long rank) { builder.AddLong(1, rank, 0); }
+  public static void AddNPCAccountLevel(FlatBufferBuilder builder, long nPCAccountLevel) { builder.AddLong(2, nPCAccountLevel, 0); }
+  public static void AddNPCLevel(FlatBufferBuilder builder, long nPCLevel) { builder.AddLong(3, nPCLevel, 0); }
+  public static void AddNPCLevelDeviation(FlatBufferBuilder builder, long nPCLevelDeviation) { builder.AddLong(4, nPCLevelDeviation, 0); }
+  public static void AddNPCStarGrade(FlatBufferBuilder builder, long nPCStarGrade) { builder.AddLong(5, nPCStarGrade, 0); }
+  public static void AddUseTSS(FlatBufferBuilder builder, bool useTSS) { builder.AddBool(6, useTSS, false); }
+  public static void AddExceptionCharacterRarities(FlatBufferBuilder builder, VectorOffset exceptionCharacterRaritiesOffset) { builder.AddOffset(7, exceptionCharacterRaritiesOffset.Value, 0); }
+  public static VectorOffset CreateExceptionCharacterRaritiesVector(FlatBufferBuilder builder, SCHALE.Common.FlatData.Rarity[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt((int)data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateExceptionCharacterRaritiesVectorBlock(FlatBufferBuilder builder, SCHALE.Common.FlatData.Rarity[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExceptionCharacterRaritiesVectorBlock(FlatBufferBuilder builder, ArraySegment<SCHALE.Common.FlatData.Rarity> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExceptionCharacterRaritiesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<SCHALE.Common.FlatData.Rarity>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartExceptionCharacterRaritiesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddExceptionMainCharacterIds(FlatBufferBuilder builder, VectorOffset exceptionMainCharacterIdsOffset) { builder.AddOffset(8, exceptionMainCharacterIdsOffset.Value, 0); }
+  public static VectorOffset CreateExceptionMainCharacterIdsVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateExceptionMainCharacterIdsVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExceptionMainCharacterIdsVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExceptionMainCharacterIdsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartExceptionMainCharacterIdsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddExceptionSupportCharacterIds(FlatBufferBuilder builder, VectorOffset exceptionSupportCharacterIdsOffset) { builder.AddOffset(9, exceptionSupportCharacterIdsOffset.Value, 0); }
+  public static VectorOffset CreateExceptionSupportCharacterIdsVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateExceptionSupportCharacterIdsVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExceptionSupportCharacterIdsVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExceptionSupportCharacterIdsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartExceptionSupportCharacterIdsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddExceptionTSSIds(FlatBufferBuilder builder, VectorOffset exceptionTSSIdsOffset) { builder.AddOffset(10, exceptionTSSIdsOffset.Value, 0); }
+  public static VectorOffset CreateExceptionTSSIdsVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateExceptionTSSIdsVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExceptionTSSIdsVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateExceptionTSSIdsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartExceptionTSSIdsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static Offset<SCHALE.Common.FlatData.ArenaNPCExcel> EndArenaNPCExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.ArenaNPCExcel>(o);
+  }
+}
+
+
+static public class ArenaNPCExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*UniqueId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*Rank*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*NPCAccountLevel*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*NPCLevel*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 12 /*NPCLevelDeviation*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 14 /*NPCStarGrade*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 16 /*UseTSS*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyVectorOfData(tablePos, 18 /*ExceptionCharacterRarities*/, 4 /*SCHALE.Common.FlatData.Rarity*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 20 /*ExceptionMainCharacterIds*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 22 /*ExceptionSupportCharacterIds*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 24 /*ExceptionTSSIds*/, 8 /*long*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/ArenaNPCExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 ArenaNPCExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static ArenaNPCExcelTable GetRootAsArenaNPCExcelTable(ByteBuffer _bb) { return GetRootAsArenaNPCExcelTable(_bb, new ArenaNPCExcelTable()); }
+  public static ArenaNPCExcelTable GetRootAsArenaNPCExcelTable(ByteBuffer _bb, ArenaNPCExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public ArenaNPCExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.ArenaNPCExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.ArenaNPCExcel?)(new SCHALE.Common.FlatData.ArenaNPCExcel()).__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.ArenaNPCExcelTable> CreateArenaNPCExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    ArenaNPCExcelTable.AddDataList(builder, DataListOffset);
+    return ArenaNPCExcelTable.EndArenaNPCExcelTable(builder);
+  }
+
+  public static void StartArenaNPCExcelTable(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.ArenaNPCExcel>[] 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.ArenaNPCExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.ArenaNPCExcel>> 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.ArenaNPCExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.ArenaNPCExcelTable> EndArenaNPCExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.ArenaNPCExcelTable>(o);
+  }
+}
+
+
+static public class ArenaNPCExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.ArenaNPCExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/ArenaRewardExcel.cs

@@ -0,0 +1,138 @@
+// <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 ArenaRewardExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static ArenaRewardExcel GetRootAsArenaRewardExcel(ByteBuffer _bb) { return GetRootAsArenaRewardExcel(_bb, new ArenaRewardExcel()); }
+  public static ArenaRewardExcel GetRootAsArenaRewardExcel(ByteBuffer _bb, ArenaRewardExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public ArenaRewardExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long UniqueId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.ArenaRewardType ArenaRewardType { get { int o = __p.__offset(6); return o != 0 ? (SCHALE.Common.FlatData.ArenaRewardType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.ArenaRewardType.None; } }
+  public long RankStart { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long RankEnd { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string RankIconPath { get { int o = __p.__offset(12); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetRankIconPathBytes() { return __p.__vector_as_span<byte>(12, 1); }
+#else
+  public ArraySegment<byte>? GetRankIconPathBytes() { return __p.__vector_as_arraysegment(12); }
+#endif
+  public byte[] GetRankIconPathArray() { return __p.__vector_as_array<byte>(12); }
+  public SCHALE.Common.FlatData.ParcelType RewardParcelType(int j) { int o = __p.__offset(14); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.ParcelType)0; }
+  public int RewardParcelTypeLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<SCHALE.Common.FlatData.ParcelType> GetRewardParcelTypeBytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.ParcelType>(14, 4); }
+#else
+  public ArraySegment<byte>? GetRewardParcelTypeBytes() { return __p.__vector_as_arraysegment(14); }
+#endif
+  public SCHALE.Common.FlatData.ParcelType[] GetRewardParcelTypeArray() { int o = __p.__offset(14); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.ParcelType[] a = new SCHALE.Common.FlatData.ParcelType[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(p + i * 4); } return a; }
+  public long RewardParcelUniqueId(int j) { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int RewardParcelUniqueIdLength { get { int o = __p.__offset(16); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetRewardParcelUniqueIdBytes() { return __p.__vector_as_span<long>(16, 8); }
+#else
+  public ArraySegment<byte>? GetRewardParcelUniqueIdBytes() { return __p.__vector_as_arraysegment(16); }
+#endif
+  public long[] GetRewardParcelUniqueIdArray() { return __p.__vector_as_array<long>(16); }
+  public string RewardParcelUniqueName(int j) { int o = __p.__offset(18); return o != 0 ? __p.__string(__p.__vector(o) + j * 4) : null; }
+  public int RewardParcelUniqueNameLength { get { int o = __p.__offset(18); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public long RewardParcelAmount(int j) { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int RewardParcelAmountLength { get { int o = __p.__offset(20); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetRewardParcelAmountBytes() { return __p.__vector_as_span<long>(20, 8); }
+#else
+  public ArraySegment<byte>? GetRewardParcelAmountBytes() { return __p.__vector_as_arraysegment(20); }
+#endif
+  public long[] GetRewardParcelAmountArray() { return __p.__vector_as_array<long>(20); }
+
+  public static Offset<SCHALE.Common.FlatData.ArenaRewardExcel> CreateArenaRewardExcel(FlatBufferBuilder builder,
+      long UniqueId = 0,
+      SCHALE.Common.FlatData.ArenaRewardType ArenaRewardType = SCHALE.Common.FlatData.ArenaRewardType.None,
+      long RankStart = 0,
+      long RankEnd = 0,
+      StringOffset RankIconPathOffset = default(StringOffset),
+      VectorOffset RewardParcelTypeOffset = default(VectorOffset),
+      VectorOffset RewardParcelUniqueIdOffset = default(VectorOffset),
+      VectorOffset RewardParcelUniqueNameOffset = default(VectorOffset),
+      VectorOffset RewardParcelAmountOffset = default(VectorOffset)) {
+    builder.StartTable(9);
+    ArenaRewardExcel.AddRankEnd(builder, RankEnd);
+    ArenaRewardExcel.AddRankStart(builder, RankStart);
+    ArenaRewardExcel.AddUniqueId(builder, UniqueId);
+    ArenaRewardExcel.AddRewardParcelAmount(builder, RewardParcelAmountOffset);
+    ArenaRewardExcel.AddRewardParcelUniqueName(builder, RewardParcelUniqueNameOffset);
+    ArenaRewardExcel.AddRewardParcelUniqueId(builder, RewardParcelUniqueIdOffset);
+    ArenaRewardExcel.AddRewardParcelType(builder, RewardParcelTypeOffset);
+    ArenaRewardExcel.AddRankIconPath(builder, RankIconPathOffset);
+    ArenaRewardExcel.AddArenaRewardType(builder, ArenaRewardType);
+    return ArenaRewardExcel.EndArenaRewardExcel(builder);
+  }
+
+  public static void StartArenaRewardExcel(FlatBufferBuilder builder) { builder.StartTable(9); }
+  public static void AddUniqueId(FlatBufferBuilder builder, long uniqueId) { builder.AddLong(0, uniqueId, 0); }
+  public static void AddArenaRewardType(FlatBufferBuilder builder, SCHALE.Common.FlatData.ArenaRewardType arenaRewardType) { builder.AddInt(1, (int)arenaRewardType, 0); }
+  public static void AddRankStart(FlatBufferBuilder builder, long rankStart) { builder.AddLong(2, rankStart, 0); }
+  public static void AddRankEnd(FlatBufferBuilder builder, long rankEnd) { builder.AddLong(3, rankEnd, 0); }
+  public static void AddRankIconPath(FlatBufferBuilder builder, StringOffset rankIconPathOffset) { builder.AddOffset(4, rankIconPathOffset.Value, 0); }
+  public static void AddRewardParcelType(FlatBufferBuilder builder, VectorOffset rewardParcelTypeOffset) { builder.AddOffset(5, rewardParcelTypeOffset.Value, 0); }
+  public static VectorOffset CreateRewardParcelTypeVector(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt((int)data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, ArraySegment<SCHALE.Common.FlatData.ParcelType> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<SCHALE.Common.FlatData.ParcelType>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardParcelTypeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddRewardParcelUniqueId(FlatBufferBuilder builder, VectorOffset rewardParcelUniqueIdOffset) { builder.AddOffset(6, rewardParcelUniqueIdOffset.Value, 0); }
+  public static VectorOffset CreateRewardParcelUniqueIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelUniqueIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelUniqueIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelUniqueIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardParcelUniqueIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddRewardParcelUniqueName(FlatBufferBuilder builder, VectorOffset rewardParcelUniqueNameOffset) { builder.AddOffset(7, rewardParcelUniqueNameOffset.Value, 0); }
+  public static VectorOffset CreateRewardParcelUniqueNameVector(FlatBufferBuilder builder, StringOffset[] 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 CreateRewardParcelUniqueNameVectorBlock(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelUniqueNameVectorBlock(FlatBufferBuilder builder, ArraySegment<StringOffset> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelUniqueNameVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<StringOffset>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardParcelUniqueNameVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddRewardParcelAmount(FlatBufferBuilder builder, VectorOffset rewardParcelAmountOffset) { builder.AddOffset(8, rewardParcelAmountOffset.Value, 0); }
+  public static VectorOffset CreateRewardParcelAmountVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelAmountVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelAmountVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelAmountVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardParcelAmountVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static Offset<SCHALE.Common.FlatData.ArenaRewardExcel> EndArenaRewardExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.ArenaRewardExcel>(o);
+  }
+}
+
+
+static public class ArenaRewardExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*UniqueId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*ArenaRewardType*/, 4 /*SCHALE.Common.FlatData.ArenaRewardType*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*RankStart*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*RankEnd*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 12 /*RankIconPath*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 14 /*RewardParcelType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 16 /*RewardParcelUniqueId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfStrings(tablePos, 18 /*RewardParcelUniqueName*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 20 /*RewardParcelAmount*/, 8 /*long*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/ArenaRewardExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 ArenaRewardExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static ArenaRewardExcelTable GetRootAsArenaRewardExcelTable(ByteBuffer _bb) { return GetRootAsArenaRewardExcelTable(_bb, new ArenaRewardExcelTable()); }
+  public static ArenaRewardExcelTable GetRootAsArenaRewardExcelTable(ByteBuffer _bb, ArenaRewardExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public ArenaRewardExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.ArenaRewardExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.ArenaRewardExcel?)(new SCHALE.Common.FlatData.ArenaRewardExcel()).__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.ArenaRewardExcelTable> CreateArenaRewardExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    ArenaRewardExcelTable.AddDataList(builder, DataListOffset);
+    return ArenaRewardExcelTable.EndArenaRewardExcelTable(builder);
+  }
+
+  public static void StartArenaRewardExcelTable(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.ArenaRewardExcel>[] 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.ArenaRewardExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.ArenaRewardExcel>> 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.ArenaRewardExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.ArenaRewardExcelTable> EndArenaRewardExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.ArenaRewardExcelTable>(o);
+  }
+}
+
+
+static public class ArenaRewardExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.ArenaRewardExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/ArenaRewardType.cs

@@ -0,0 +1,22 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum ArenaRewardType : int
+{
+  None = 0,
+  Time = 1,
+  Daily = 2,
+  SeasonRecord = 3,
+  OverallRecord = 4,
+  SeasonClose = 5,
+  AttackVictory = 6,
+  DefenseVictory = 7,
+  RankIcon = 8,
+};
+
+
+}

SCHALE.Common/FlatData/ArenaSeasonCloseRewardExcel.cs

@@ -0,0 +1,122 @@
+// <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 ArenaSeasonCloseRewardExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static ArenaSeasonCloseRewardExcel GetRootAsArenaSeasonCloseRewardExcel(ByteBuffer _bb) { return GetRootAsArenaSeasonCloseRewardExcel(_bb, new ArenaSeasonCloseRewardExcel()); }
+  public static ArenaSeasonCloseRewardExcel GetRootAsArenaSeasonCloseRewardExcel(ByteBuffer _bb, ArenaSeasonCloseRewardExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public ArenaSeasonCloseRewardExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long SeasonId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long RankStart { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long RankEnd { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.ParcelType RewardParcelType(int j) { int o = __p.__offset(10); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.ParcelType)0; }
+  public int RewardParcelTypeLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<SCHALE.Common.FlatData.ParcelType> GetRewardParcelTypeBytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.ParcelType>(10, 4); }
+#else
+  public ArraySegment<byte>? GetRewardParcelTypeBytes() { return __p.__vector_as_arraysegment(10); }
+#endif
+  public SCHALE.Common.FlatData.ParcelType[] GetRewardParcelTypeArray() { int o = __p.__offset(10); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.ParcelType[] a = new SCHALE.Common.FlatData.ParcelType[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(p + i * 4); } return a; }
+  public long RewardParcelUniqueId(int j) { int o = __p.__offset(12); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int RewardParcelUniqueIdLength { get { int o = __p.__offset(12); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetRewardParcelUniqueIdBytes() { return __p.__vector_as_span<long>(12, 8); }
+#else
+  public ArraySegment<byte>? GetRewardParcelUniqueIdBytes() { return __p.__vector_as_arraysegment(12); }
+#endif
+  public long[] GetRewardParcelUniqueIdArray() { return __p.__vector_as_array<long>(12); }
+  public string RewardParcelUniqueName(int j) { int o = __p.__offset(14); return o != 0 ? __p.__string(__p.__vector(o) + j * 4) : null; }
+  public int RewardParcelUniqueNameLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public long RewardParcelAmount(int j) { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int RewardParcelAmountLength { get { int o = __p.__offset(16); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetRewardParcelAmountBytes() { return __p.__vector_as_span<long>(16, 8); }
+#else
+  public ArraySegment<byte>? GetRewardParcelAmountBytes() { return __p.__vector_as_arraysegment(16); }
+#endif
+  public long[] GetRewardParcelAmountArray() { return __p.__vector_as_array<long>(16); }
+
+  public static Offset<SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcel> CreateArenaSeasonCloseRewardExcel(FlatBufferBuilder builder,
+      long SeasonId = 0,
+      long RankStart = 0,
+      long RankEnd = 0,
+      VectorOffset RewardParcelTypeOffset = default(VectorOffset),
+      VectorOffset RewardParcelUniqueIdOffset = default(VectorOffset),
+      VectorOffset RewardParcelUniqueNameOffset = default(VectorOffset),
+      VectorOffset RewardParcelAmountOffset = default(VectorOffset)) {
+    builder.StartTable(7);
+    ArenaSeasonCloseRewardExcel.AddRankEnd(builder, RankEnd);
+    ArenaSeasonCloseRewardExcel.AddRankStart(builder, RankStart);
+    ArenaSeasonCloseRewardExcel.AddSeasonId(builder, SeasonId);
+    ArenaSeasonCloseRewardExcel.AddRewardParcelAmount(builder, RewardParcelAmountOffset);
+    ArenaSeasonCloseRewardExcel.AddRewardParcelUniqueName(builder, RewardParcelUniqueNameOffset);
+    ArenaSeasonCloseRewardExcel.AddRewardParcelUniqueId(builder, RewardParcelUniqueIdOffset);
+    ArenaSeasonCloseRewardExcel.AddRewardParcelType(builder, RewardParcelTypeOffset);
+    return ArenaSeasonCloseRewardExcel.EndArenaSeasonCloseRewardExcel(builder);
+  }
+
+  public static void StartArenaSeasonCloseRewardExcel(FlatBufferBuilder builder) { builder.StartTable(7); }
+  public static void AddSeasonId(FlatBufferBuilder builder, long seasonId) { builder.AddLong(0, seasonId, 0); }
+  public static void AddRankStart(FlatBufferBuilder builder, long rankStart) { builder.AddLong(1, rankStart, 0); }
+  public static void AddRankEnd(FlatBufferBuilder builder, long rankEnd) { builder.AddLong(2, rankEnd, 0); }
+  public static void AddRewardParcelType(FlatBufferBuilder builder, VectorOffset rewardParcelTypeOffset) { builder.AddOffset(3, rewardParcelTypeOffset.Value, 0); }
+  public static VectorOffset CreateRewardParcelTypeVector(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt((int)data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, ArraySegment<SCHALE.Common.FlatData.ParcelType> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<SCHALE.Common.FlatData.ParcelType>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardParcelTypeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddRewardParcelUniqueId(FlatBufferBuilder builder, VectorOffset rewardParcelUniqueIdOffset) { builder.AddOffset(4, rewardParcelUniqueIdOffset.Value, 0); }
+  public static VectorOffset CreateRewardParcelUniqueIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelUniqueIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelUniqueIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelUniqueIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardParcelUniqueIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddRewardParcelUniqueName(FlatBufferBuilder builder, VectorOffset rewardParcelUniqueNameOffset) { builder.AddOffset(5, rewardParcelUniqueNameOffset.Value, 0); }
+  public static VectorOffset CreateRewardParcelUniqueNameVector(FlatBufferBuilder builder, StringOffset[] 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 CreateRewardParcelUniqueNameVectorBlock(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelUniqueNameVectorBlock(FlatBufferBuilder builder, ArraySegment<StringOffset> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelUniqueNameVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<StringOffset>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardParcelUniqueNameVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddRewardParcelAmount(FlatBufferBuilder builder, VectorOffset rewardParcelAmountOffset) { builder.AddOffset(6, rewardParcelAmountOffset.Value, 0); }
+  public static VectorOffset CreateRewardParcelAmountVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelAmountVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelAmountVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelAmountVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardParcelAmountVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static Offset<SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcel> EndArenaSeasonCloseRewardExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcel>(o);
+  }
+}
+
+
+static public class ArenaSeasonCloseRewardExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*SeasonId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*RankStart*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*RankEnd*/, 8 /*long*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 10 /*RewardParcelType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 12 /*RewardParcelUniqueId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfStrings(tablePos, 14 /*RewardParcelUniqueName*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 16 /*RewardParcelAmount*/, 8 /*long*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/ArenaSeasonCloseRewardExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 ArenaSeasonCloseRewardExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static ArenaSeasonCloseRewardExcelTable GetRootAsArenaSeasonCloseRewardExcelTable(ByteBuffer _bb) { return GetRootAsArenaSeasonCloseRewardExcelTable(_bb, new ArenaSeasonCloseRewardExcelTable()); }
+  public static ArenaSeasonCloseRewardExcelTable GetRootAsArenaSeasonCloseRewardExcelTable(ByteBuffer _bb, ArenaSeasonCloseRewardExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public ArenaSeasonCloseRewardExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcel?)(new SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcel()).__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.ArenaSeasonCloseRewardExcelTable> CreateArenaSeasonCloseRewardExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    ArenaSeasonCloseRewardExcelTable.AddDataList(builder, DataListOffset);
+    return ArenaSeasonCloseRewardExcelTable.EndArenaSeasonCloseRewardExcelTable(builder);
+  }
+
+  public static void StartArenaSeasonCloseRewardExcelTable(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.ArenaSeasonCloseRewardExcel>[] 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.ArenaSeasonCloseRewardExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcel>> 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.ArenaSeasonCloseRewardExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcelTable> EndArenaSeasonCloseRewardExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcelTable>(o);
+  }
+}
+
+
+static public class ArenaSeasonCloseRewardExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.ArenaSeasonCloseRewardExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/ArenaSeasonExcel.cs

@@ -0,0 +1,82 @@
+// <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 ArenaSeasonExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static ArenaSeasonExcel GetRootAsArenaSeasonExcel(ByteBuffer _bb) { return GetRootAsArenaSeasonExcel(_bb, new ArenaSeasonExcel()); }
+  public static ArenaSeasonExcel GetRootAsArenaSeasonExcel(ByteBuffer _bb, ArenaSeasonExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public ArenaSeasonExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long UniqueId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string SeasonStartDate { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetSeasonStartDateBytes() { return __p.__vector_as_span<byte>(6, 1); }
+#else
+  public ArraySegment<byte>? GetSeasonStartDateBytes() { return __p.__vector_as_arraysegment(6); }
+#endif
+  public byte[] GetSeasonStartDateArray() { return __p.__vector_as_array<byte>(6); }
+  public string SeasonEndDate { get { int o = __p.__offset(8); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetSeasonEndDateBytes() { return __p.__vector_as_span<byte>(8, 1); }
+#else
+  public ArraySegment<byte>? GetSeasonEndDateBytes() { return __p.__vector_as_arraysegment(8); }
+#endif
+  public byte[] GetSeasonEndDateArray() { return __p.__vector_as_array<byte>(8); }
+  public long SeasonGroupLimit { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long PrevSeasonId { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+
+  public static Offset<SCHALE.Common.FlatData.ArenaSeasonExcel> CreateArenaSeasonExcel(FlatBufferBuilder builder,
+      long UniqueId = 0,
+      StringOffset SeasonStartDateOffset = default(StringOffset),
+      StringOffset SeasonEndDateOffset = default(StringOffset),
+      long SeasonGroupLimit = 0,
+      long PrevSeasonId = 0) {
+    builder.StartTable(5);
+    ArenaSeasonExcel.AddPrevSeasonId(builder, PrevSeasonId);
+    ArenaSeasonExcel.AddSeasonGroupLimit(builder, SeasonGroupLimit);
+    ArenaSeasonExcel.AddUniqueId(builder, UniqueId);
+    ArenaSeasonExcel.AddSeasonEndDate(builder, SeasonEndDateOffset);
+    ArenaSeasonExcel.AddSeasonStartDate(builder, SeasonStartDateOffset);
+    return ArenaSeasonExcel.EndArenaSeasonExcel(builder);
+  }
+
+  public static void StartArenaSeasonExcel(FlatBufferBuilder builder) { builder.StartTable(5); }
+  public static void AddUniqueId(FlatBufferBuilder builder, long uniqueId) { builder.AddLong(0, uniqueId, 0); }
+  public static void AddSeasonStartDate(FlatBufferBuilder builder, StringOffset seasonStartDateOffset) { builder.AddOffset(1, seasonStartDateOffset.Value, 0); }
+  public static void AddSeasonEndDate(FlatBufferBuilder builder, StringOffset seasonEndDateOffset) { builder.AddOffset(2, seasonEndDateOffset.Value, 0); }
+  public static void AddSeasonGroupLimit(FlatBufferBuilder builder, long seasonGroupLimit) { builder.AddLong(3, seasonGroupLimit, 0); }
+  public static void AddPrevSeasonId(FlatBufferBuilder builder, long prevSeasonId) { builder.AddLong(4, prevSeasonId, 0); }
+  public static Offset<SCHALE.Common.FlatData.ArenaSeasonExcel> EndArenaSeasonExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.ArenaSeasonExcel>(o);
+  }
+}
+
+
+static public class ArenaSeasonExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*UniqueId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 6 /*SeasonStartDate*/, false)
+      && verifier.VerifyString(tablePos, 8 /*SeasonEndDate*/, false)
+      && verifier.VerifyField(tablePos, 10 /*SeasonGroupLimit*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 12 /*PrevSeasonId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/ArenaSeasonExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 ArenaSeasonExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static ArenaSeasonExcelTable GetRootAsArenaSeasonExcelTable(ByteBuffer _bb) { return GetRootAsArenaSeasonExcelTable(_bb, new ArenaSeasonExcelTable()); }
+  public static ArenaSeasonExcelTable GetRootAsArenaSeasonExcelTable(ByteBuffer _bb, ArenaSeasonExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public ArenaSeasonExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.ArenaSeasonExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.ArenaSeasonExcel?)(new SCHALE.Common.FlatData.ArenaSeasonExcel()).__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.ArenaSeasonExcelTable> CreateArenaSeasonExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    ArenaSeasonExcelTable.AddDataList(builder, DataListOffset);
+    return ArenaSeasonExcelTable.EndArenaSeasonExcelTable(builder);
+  }
+
+  public static void StartArenaSeasonExcelTable(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.ArenaSeasonExcel>[] 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.ArenaSeasonExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.ArenaSeasonExcel>> 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.ArenaSeasonExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.ArenaSeasonExcelTable> EndArenaSeasonExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.ArenaSeasonExcelTable>(o);
+  }
+}
+
+
+static public class ArenaSeasonExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.ArenaSeasonExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/ArenaSimulatorServer.cs

@@ -0,0 +1,17 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum ArenaSimulatorServer : int
+{
+  Preset = 0,
+  Live = 1,
+  Dev = 2,
+  QA = 3,
+};
+
+
+}

SCHALE.Common/FlatData/ArmorType.cs

@@ -0,0 +1,19 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum ArmorType : int
+{
+  LightArmor = 0,
+  HeavyArmor = 1,
+  Unarmed = 2,
+  Structure = 3,
+  Normal = 4,
+  ElasticArmor = 5,
+};
+
+
+}

SCHALE.Common/FlatData/AttackType.cs

@@ -0,0 +1,17 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum AttackType : int
+{
+  Single = 0,
+  Splash = 1,
+  Through = 2,
+  Heal = 3,
+};
+
+
+}

SCHALE.Common/FlatData/AttendanceCountRule.cs

@@ -0,0 +1,15 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum AttendanceCountRule : int
+{
+  Accumulation = 0,
+  Date = 1,
+};
+
+
+}

SCHALE.Common/FlatData/AttendanceExcel.cs

@@ -0,0 +1,188 @@
+// <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 AttendanceExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AttendanceExcel GetRootAsAttendanceExcel(ByteBuffer _bb) { return GetRootAsAttendanceExcel(_bb, new AttendanceExcel()); }
+  public static AttendanceExcel GetRootAsAttendanceExcel(ByteBuffer _bb, AttendanceExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AttendanceExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long Id { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.AttendanceType Type { get { int o = __p.__offset(6); return o != 0 ? (SCHALE.Common.FlatData.AttendanceType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.AttendanceType.Basic; } }
+  public string CountdownPrefab { get { int o = __p.__offset(8); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetCountdownPrefabBytes() { return __p.__vector_as_span<byte>(8, 1); }
+#else
+  public ArraySegment<byte>? GetCountdownPrefabBytes() { return __p.__vector_as_arraysegment(8); }
+#endif
+  public byte[] GetCountdownPrefabArray() { return __p.__vector_as_array<byte>(8); }
+  public long DisplayOrder { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.AccountState AccountType { get { int o = __p.__offset(12); return o != 0 ? (SCHALE.Common.FlatData.AccountState)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.AccountState.WaitingSignIn; } }
+  public long AccountLevelLimit { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string Title { get { int o = __p.__offset(16); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetTitleBytes() { return __p.__vector_as_span<byte>(16, 1); }
+#else
+  public ArraySegment<byte>? GetTitleBytes() { return __p.__vector_as_arraysegment(16); }
+#endif
+  public byte[] GetTitleArray() { return __p.__vector_as_array<byte>(16); }
+  public string InfomationLocalizeCode { get { int o = __p.__offset(18); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetInfomationLocalizeCodeBytes() { return __p.__vector_as_span<byte>(18, 1); }
+#else
+  public ArraySegment<byte>? GetInfomationLocalizeCodeBytes() { return __p.__vector_as_arraysegment(18); }
+#endif
+  public byte[] GetInfomationLocalizeCodeArray() { return __p.__vector_as_array<byte>(18); }
+  public SCHALE.Common.FlatData.AttendanceCountRule CountRule { get { int o = __p.__offset(20); return o != 0 ? (SCHALE.Common.FlatData.AttendanceCountRule)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.AttendanceCountRule.Accumulation; } }
+  public SCHALE.Common.FlatData.AttendanceResetType CountReset { get { int o = __p.__offset(22); return o != 0 ? (SCHALE.Common.FlatData.AttendanceResetType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.AttendanceResetType.User; } }
+  public long BookSize { get { int o = __p.__offset(24); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string StartDate { get { int o = __p.__offset(26); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetStartDateBytes() { return __p.__vector_as_span<byte>(26, 1); }
+#else
+  public ArraySegment<byte>? GetStartDateBytes() { return __p.__vector_as_arraysegment(26); }
+#endif
+  public byte[] GetStartDateArray() { return __p.__vector_as_array<byte>(26); }
+  public string StartableEndDate { get { int o = __p.__offset(28); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetStartableEndDateBytes() { return __p.__vector_as_span<byte>(28, 1); }
+#else
+  public ArraySegment<byte>? GetStartableEndDateBytes() { return __p.__vector_as_arraysegment(28); }
+#endif
+  public byte[] GetStartableEndDateArray() { return __p.__vector_as_array<byte>(28); }
+  public string EndDate { get { int o = __p.__offset(30); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetEndDateBytes() { return __p.__vector_as_span<byte>(30, 1); }
+#else
+  public ArraySegment<byte>? GetEndDateBytes() { return __p.__vector_as_arraysegment(30); }
+#endif
+  public byte[] GetEndDateArray() { return __p.__vector_as_array<byte>(30); }
+  public long ExpiryDate { get { int o = __p.__offset(32); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.MailType MailType { get { int o = __p.__offset(34); return o != 0 ? (SCHALE.Common.FlatData.MailType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.MailType.System; } }
+  public SCHALE.Common.FlatData.DialogCategory DialogCategory { get { int o = __p.__offset(36); return o != 0 ? (SCHALE.Common.FlatData.DialogCategory)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.DialogCategory.Cafe; } }
+  public string TitleImagePath { get { int o = __p.__offset(38); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetTitleImagePathBytes() { return __p.__vector_as_span<byte>(38, 1); }
+#else
+  public ArraySegment<byte>? GetTitleImagePathBytes() { return __p.__vector_as_arraysegment(38); }
+#endif
+  public byte[] GetTitleImagePathArray() { return __p.__vector_as_array<byte>(38); }
+  public string DecorationImagePath { get { int o = __p.__offset(40); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetDecorationImagePathBytes() { return __p.__vector_as_span<byte>(40, 1); }
+#else
+  public ArraySegment<byte>? GetDecorationImagePathBytes() { return __p.__vector_as_arraysegment(40); }
+#endif
+  public byte[] GetDecorationImagePathArray() { return __p.__vector_as_array<byte>(40); }
+
+  public static Offset<SCHALE.Common.FlatData.AttendanceExcel> CreateAttendanceExcel(FlatBufferBuilder builder,
+      long Id = 0,
+      SCHALE.Common.FlatData.AttendanceType Type = SCHALE.Common.FlatData.AttendanceType.Basic,
+      StringOffset CountdownPrefabOffset = default(StringOffset),
+      long DisplayOrder = 0,
+      SCHALE.Common.FlatData.AccountState AccountType = SCHALE.Common.FlatData.AccountState.WaitingSignIn,
+      long AccountLevelLimit = 0,
+      StringOffset TitleOffset = default(StringOffset),
+      StringOffset InfomationLocalizeCodeOffset = default(StringOffset),
+      SCHALE.Common.FlatData.AttendanceCountRule CountRule = SCHALE.Common.FlatData.AttendanceCountRule.Accumulation,
+      SCHALE.Common.FlatData.AttendanceResetType CountReset = SCHALE.Common.FlatData.AttendanceResetType.User,
+      long BookSize = 0,
+      StringOffset StartDateOffset = default(StringOffset),
+      StringOffset StartableEndDateOffset = default(StringOffset),
+      StringOffset EndDateOffset = default(StringOffset),
+      long ExpiryDate = 0,
+      SCHALE.Common.FlatData.MailType MailType = SCHALE.Common.FlatData.MailType.System,
+      SCHALE.Common.FlatData.DialogCategory DialogCategory = SCHALE.Common.FlatData.DialogCategory.Cafe,
+      StringOffset TitleImagePathOffset = default(StringOffset),
+      StringOffset DecorationImagePathOffset = default(StringOffset)) {
+    builder.StartTable(19);
+    AttendanceExcel.AddExpiryDate(builder, ExpiryDate);
+    AttendanceExcel.AddBookSize(builder, BookSize);
+    AttendanceExcel.AddAccountLevelLimit(builder, AccountLevelLimit);
+    AttendanceExcel.AddDisplayOrder(builder, DisplayOrder);
+    AttendanceExcel.AddId(builder, Id);
+    AttendanceExcel.AddDecorationImagePath(builder, DecorationImagePathOffset);
+    AttendanceExcel.AddTitleImagePath(builder, TitleImagePathOffset);
+    AttendanceExcel.AddDialogCategory(builder, DialogCategory);
+    AttendanceExcel.AddMailType(builder, MailType);
+    AttendanceExcel.AddEndDate(builder, EndDateOffset);
+    AttendanceExcel.AddStartableEndDate(builder, StartableEndDateOffset);
+    AttendanceExcel.AddStartDate(builder, StartDateOffset);
+    AttendanceExcel.AddCountReset(builder, CountReset);
+    AttendanceExcel.AddCountRule(builder, CountRule);
+    AttendanceExcel.AddInfomationLocalizeCode(builder, InfomationLocalizeCodeOffset);
+    AttendanceExcel.AddTitle(builder, TitleOffset);
+    AttendanceExcel.AddAccountType(builder, AccountType);
+    AttendanceExcel.AddCountdownPrefab(builder, CountdownPrefabOffset);
+    AttendanceExcel.AddType(builder, Type);
+    return AttendanceExcel.EndAttendanceExcel(builder);
+  }
+
+  public static void StartAttendanceExcel(FlatBufferBuilder builder) { builder.StartTable(19); }
+  public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
+  public static void AddType(FlatBufferBuilder builder, SCHALE.Common.FlatData.AttendanceType type) { builder.AddInt(1, (int)type, 0); }
+  public static void AddCountdownPrefab(FlatBufferBuilder builder, StringOffset countdownPrefabOffset) { builder.AddOffset(2, countdownPrefabOffset.Value, 0); }
+  public static void AddDisplayOrder(FlatBufferBuilder builder, long displayOrder) { builder.AddLong(3, displayOrder, 0); }
+  public static void AddAccountType(FlatBufferBuilder builder, SCHALE.Common.FlatData.AccountState accountType) { builder.AddInt(4, (int)accountType, 0); }
+  public static void AddAccountLevelLimit(FlatBufferBuilder builder, long accountLevelLimit) { builder.AddLong(5, accountLevelLimit, 0); }
+  public static void AddTitle(FlatBufferBuilder builder, StringOffset titleOffset) { builder.AddOffset(6, titleOffset.Value, 0); }
+  public static void AddInfomationLocalizeCode(FlatBufferBuilder builder, StringOffset infomationLocalizeCodeOffset) { builder.AddOffset(7, infomationLocalizeCodeOffset.Value, 0); }
+  public static void AddCountRule(FlatBufferBuilder builder, SCHALE.Common.FlatData.AttendanceCountRule countRule) { builder.AddInt(8, (int)countRule, 0); }
+  public static void AddCountReset(FlatBufferBuilder builder, SCHALE.Common.FlatData.AttendanceResetType countReset) { builder.AddInt(9, (int)countReset, 0); }
+  public static void AddBookSize(FlatBufferBuilder builder, long bookSize) { builder.AddLong(10, bookSize, 0); }
+  public static void AddStartDate(FlatBufferBuilder builder, StringOffset startDateOffset) { builder.AddOffset(11, startDateOffset.Value, 0); }
+  public static void AddStartableEndDate(FlatBufferBuilder builder, StringOffset startableEndDateOffset) { builder.AddOffset(12, startableEndDateOffset.Value, 0); }
+  public static void AddEndDate(FlatBufferBuilder builder, StringOffset endDateOffset) { builder.AddOffset(13, endDateOffset.Value, 0); }
+  public static void AddExpiryDate(FlatBufferBuilder builder, long expiryDate) { builder.AddLong(14, expiryDate, 0); }
+  public static void AddMailType(FlatBufferBuilder builder, SCHALE.Common.FlatData.MailType mailType) { builder.AddInt(15, (int)mailType, 0); }
+  public static void AddDialogCategory(FlatBufferBuilder builder, SCHALE.Common.FlatData.DialogCategory dialogCategory) { builder.AddInt(16, (int)dialogCategory, 0); }
+  public static void AddTitleImagePath(FlatBufferBuilder builder, StringOffset titleImagePathOffset) { builder.AddOffset(17, titleImagePathOffset.Value, 0); }
+  public static void AddDecorationImagePath(FlatBufferBuilder builder, StringOffset decorationImagePathOffset) { builder.AddOffset(18, decorationImagePathOffset.Value, 0); }
+  public static Offset<SCHALE.Common.FlatData.AttendanceExcel> EndAttendanceExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AttendanceExcel>(o);
+  }
+}
+
+
+static public class AttendanceExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*Type*/, 4 /*SCHALE.Common.FlatData.AttendanceType*/, 4, false)
+      && verifier.VerifyString(tablePos, 8 /*CountdownPrefab*/, false)
+      && verifier.VerifyField(tablePos, 10 /*DisplayOrder*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 12 /*AccountType*/, 4 /*SCHALE.Common.FlatData.AccountState*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*AccountLevelLimit*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 16 /*Title*/, false)
+      && verifier.VerifyString(tablePos, 18 /*InfomationLocalizeCode*/, false)
+      && verifier.VerifyField(tablePos, 20 /*CountRule*/, 4 /*SCHALE.Common.FlatData.AttendanceCountRule*/, 4, false)
+      && verifier.VerifyField(tablePos, 22 /*CountReset*/, 4 /*SCHALE.Common.FlatData.AttendanceResetType*/, 4, false)
+      && verifier.VerifyField(tablePos, 24 /*BookSize*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 26 /*StartDate*/, false)
+      && verifier.VerifyString(tablePos, 28 /*StartableEndDate*/, false)
+      && verifier.VerifyString(tablePos, 30 /*EndDate*/, false)
+      && verifier.VerifyField(tablePos, 32 /*ExpiryDate*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 34 /*MailType*/, 4 /*SCHALE.Common.FlatData.MailType*/, 4, false)
+      && verifier.VerifyField(tablePos, 36 /*DialogCategory*/, 4 /*SCHALE.Common.FlatData.DialogCategory*/, 4, false)
+      && verifier.VerifyString(tablePos, 38 /*TitleImagePath*/, false)
+      && verifier.VerifyString(tablePos, 40 /*DecorationImagePath*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AttendanceExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 AttendanceExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AttendanceExcelTable GetRootAsAttendanceExcelTable(ByteBuffer _bb) { return GetRootAsAttendanceExcelTable(_bb, new AttendanceExcelTable()); }
+  public static AttendanceExcelTable GetRootAsAttendanceExcelTable(ByteBuffer _bb, AttendanceExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AttendanceExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.AttendanceExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.AttendanceExcel?)(new SCHALE.Common.FlatData.AttendanceExcel()).__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.AttendanceExcelTable> CreateAttendanceExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    AttendanceExcelTable.AddDataList(builder, DataListOffset);
+    return AttendanceExcelTable.EndAttendanceExcelTable(builder);
+  }
+
+  public static void StartAttendanceExcelTable(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.AttendanceExcel>[] 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.AttendanceExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AttendanceExcel>> 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.AttendanceExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AttendanceExcelTable> EndAttendanceExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AttendanceExcelTable>(o);
+  }
+}
+
+
+static public class AttendanceExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.AttendanceExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AttendanceResetType.cs

@@ -0,0 +1,15 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum AttendanceResetType : int
+{
+  User = 0,
+  Server = 1,
+};
+
+
+}

SCHALE.Common/FlatData/AttendanceRewardExcel.cs

@@ -0,0 +1,117 @@
+// <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 AttendanceRewardExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AttendanceRewardExcel GetRootAsAttendanceRewardExcel(ByteBuffer _bb) { return GetRootAsAttendanceRewardExcel(_bb, new AttendanceRewardExcel()); }
+  public static AttendanceRewardExcel GetRootAsAttendanceRewardExcel(ByteBuffer _bb, AttendanceRewardExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AttendanceRewardExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long AttendanceId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long Day { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string RewardIcon { get { int o = __p.__offset(8); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetRewardIconBytes() { return __p.__vector_as_span<byte>(8, 1); }
+#else
+  public ArraySegment<byte>? GetRewardIconBytes() { return __p.__vector_as_arraysegment(8); }
+#endif
+  public byte[] GetRewardIconArray() { return __p.__vector_as_array<byte>(8); }
+  public SCHALE.Common.FlatData.ParcelType RewardParcelType(int j) { int o = __p.__offset(10); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.ParcelType)0; }
+  public int RewardParcelTypeLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<SCHALE.Common.FlatData.ParcelType> GetRewardParcelTypeBytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.ParcelType>(10, 4); }
+#else
+  public ArraySegment<byte>? GetRewardParcelTypeBytes() { return __p.__vector_as_arraysegment(10); }
+#endif
+  public SCHALE.Common.FlatData.ParcelType[] GetRewardParcelTypeArray() { int o = __p.__offset(10); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.ParcelType[] a = new SCHALE.Common.FlatData.ParcelType[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(p + i * 4); } return a; }
+  public long RewardId(int j) { int o = __p.__offset(12); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int RewardIdLength { get { int o = __p.__offset(12); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetRewardIdBytes() { return __p.__vector_as_span<long>(12, 8); }
+#else
+  public ArraySegment<byte>? GetRewardIdBytes() { return __p.__vector_as_arraysegment(12); }
+#endif
+  public long[] GetRewardIdArray() { return __p.__vector_as_array<long>(12); }
+  public long RewardAmount(int j) { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int RewardAmountLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetRewardAmountBytes() { return __p.__vector_as_span<long>(14, 8); }
+#else
+  public ArraySegment<byte>? GetRewardAmountBytes() { return __p.__vector_as_arraysegment(14); }
+#endif
+  public long[] GetRewardAmountArray() { return __p.__vector_as_array<long>(14); }
+
+  public static Offset<SCHALE.Common.FlatData.AttendanceRewardExcel> CreateAttendanceRewardExcel(FlatBufferBuilder builder,
+      long AttendanceId = 0,
+      long Day = 0,
+      StringOffset RewardIconOffset = default(StringOffset),
+      VectorOffset RewardParcelTypeOffset = default(VectorOffset),
+      VectorOffset RewardIdOffset = default(VectorOffset),
+      VectorOffset RewardAmountOffset = default(VectorOffset)) {
+    builder.StartTable(6);
+    AttendanceRewardExcel.AddDay(builder, Day);
+    AttendanceRewardExcel.AddAttendanceId(builder, AttendanceId);
+    AttendanceRewardExcel.AddRewardAmount(builder, RewardAmountOffset);
+    AttendanceRewardExcel.AddRewardId(builder, RewardIdOffset);
+    AttendanceRewardExcel.AddRewardParcelType(builder, RewardParcelTypeOffset);
+    AttendanceRewardExcel.AddRewardIcon(builder, RewardIconOffset);
+    return AttendanceRewardExcel.EndAttendanceRewardExcel(builder);
+  }
+
+  public static void StartAttendanceRewardExcel(FlatBufferBuilder builder) { builder.StartTable(6); }
+  public static void AddAttendanceId(FlatBufferBuilder builder, long attendanceId) { builder.AddLong(0, attendanceId, 0); }
+  public static void AddDay(FlatBufferBuilder builder, long day) { builder.AddLong(1, day, 0); }
+  public static void AddRewardIcon(FlatBufferBuilder builder, StringOffset rewardIconOffset) { builder.AddOffset(2, rewardIconOffset.Value, 0); }
+  public static void AddRewardParcelType(FlatBufferBuilder builder, VectorOffset rewardParcelTypeOffset) { builder.AddOffset(3, rewardParcelTypeOffset.Value, 0); }
+  public static VectorOffset CreateRewardParcelTypeVector(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt((int)data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, ArraySegment<SCHALE.Common.FlatData.ParcelType> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<SCHALE.Common.FlatData.ParcelType>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardParcelTypeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddRewardId(FlatBufferBuilder builder, VectorOffset rewardIdOffset) { builder.AddOffset(4, rewardIdOffset.Value, 0); }
+  public static VectorOffset CreateRewardIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateRewardIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddRewardAmount(FlatBufferBuilder builder, VectorOffset rewardAmountOffset) { builder.AddOffset(5, rewardAmountOffset.Value, 0); }
+  public static VectorOffset CreateRewardAmountVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateRewardAmountVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardAmountVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateRewardAmountVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartRewardAmountVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static Offset<SCHALE.Common.FlatData.AttendanceRewardExcel> EndAttendanceRewardExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AttendanceRewardExcel>(o);
+  }
+}
+
+
+static public class AttendanceRewardExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*AttendanceId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*Day*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 8 /*RewardIcon*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 10 /*RewardParcelType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 12 /*RewardId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 14 /*RewardAmount*/, 8 /*long*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AttendanceRewardExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 AttendanceRewardExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AttendanceRewardExcelTable GetRootAsAttendanceRewardExcelTable(ByteBuffer _bb) { return GetRootAsAttendanceRewardExcelTable(_bb, new AttendanceRewardExcelTable()); }
+  public static AttendanceRewardExcelTable GetRootAsAttendanceRewardExcelTable(ByteBuffer _bb, AttendanceRewardExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AttendanceRewardExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.AttendanceRewardExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.AttendanceRewardExcel?)(new SCHALE.Common.FlatData.AttendanceRewardExcel()).__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.AttendanceRewardExcelTable> CreateAttendanceRewardExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    AttendanceRewardExcelTable.AddDataList(builder, DataListOffset);
+    return AttendanceRewardExcelTable.EndAttendanceRewardExcelTable(builder);
+  }
+
+  public static void StartAttendanceRewardExcelTable(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.AttendanceRewardExcel>[] 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.AttendanceRewardExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.AttendanceRewardExcel>> 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.AttendanceRewardExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AttendanceRewardExcelTable> EndAttendanceRewardExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AttendanceRewardExcelTable>(o);
+  }
+}
+
+
+static public class AttendanceRewardExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.AttendanceRewardExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/AttendanceType.cs

@@ -0,0 +1,18 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum AttendanceType : int
+{
+  Basic = 0,
+  Event = 1,
+  Newbie = 2,
+  EventCountDown = 3,
+  Event20Days = 4,
+};
+
+
+}

SCHALE.Common/FlatData/AudioAnimatorExcel.cs

@@ -0,0 +1,140 @@
+// <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 AudioAnimatorExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static AudioAnimatorExcel GetRootAsAudioAnimatorExcel(ByteBuffer _bb) { return GetRootAsAudioAnimatorExcel(_bb, new AudioAnimatorExcel()); }
+  public static AudioAnimatorExcel GetRootAsAudioAnimatorExcel(ByteBuffer _bb, AudioAnimatorExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public AudioAnimatorExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public uint ControllerNameHash { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public string VoiceNamePrefix { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetVoiceNamePrefixBytes() { return __p.__vector_as_span<byte>(6, 1); }
+#else
+  public ArraySegment<byte>? GetVoiceNamePrefixBytes() { return __p.__vector_as_arraysegment(6); }
+#endif
+  public byte[] GetVoiceNamePrefixArray() { return __p.__vector_as_array<byte>(6); }
+  public uint StateNameHash { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public string StateName { get { int o = __p.__offset(10); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetStateNameBytes() { return __p.__vector_as_span<byte>(10, 1); }
+#else
+  public ArraySegment<byte>? GetStateNameBytes() { return __p.__vector_as_arraysegment(10); }
+#endif
+  public byte[] GetStateNameArray() { return __p.__vector_as_array<byte>(10); }
+  public bool IgnoreInterruptDelay { get { int o = __p.__offset(12); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public bool IgnoreInterruptPlay { get { int o = __p.__offset(14); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public float Volume { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public float Delay { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public int RandomPitchMin { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public int RandomPitchMax { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public int AudioPriority { get { int o = __p.__offset(24); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public string AudioClipPath(int j) { int o = __p.__offset(26); return o != 0 ? __p.__string(__p.__vector(o) + j * 4) : null; }
+  public int AudioClipPathLength { get { int o = __p.__offset(26); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public uint VoiceHash(int j) { int o = __p.__offset(28); return o != 0 ? __p.bb.GetUint(__p.__vector(o) + j * 4) : (uint)0; }
+  public int VoiceHashLength { get { int o = __p.__offset(28); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<uint> GetVoiceHashBytes() { return __p.__vector_as_span<uint>(28, 4); }
+#else
+  public ArraySegment<byte>? GetVoiceHashBytes() { return __p.__vector_as_arraysegment(28); }
+#endif
+  public uint[] GetVoiceHashArray() { return __p.__vector_as_array<uint>(28); }
+
+  public static Offset<SCHALE.Common.FlatData.AudioAnimatorExcel> CreateAudioAnimatorExcel(FlatBufferBuilder builder,
+      uint ControllerNameHash = 0,
+      StringOffset VoiceNamePrefixOffset = default(StringOffset),
+      uint StateNameHash = 0,
+      StringOffset StateNameOffset = default(StringOffset),
+      bool IgnoreInterruptDelay = false,
+      bool IgnoreInterruptPlay = false,
+      float Volume = 0.0f,
+      float Delay = 0.0f,
+      int RandomPitchMin = 0,
+      int RandomPitchMax = 0,
+      int AudioPriority = 0,
+      VectorOffset AudioClipPathOffset = default(VectorOffset),
+      VectorOffset VoiceHashOffset = default(VectorOffset)) {
+    builder.StartTable(13);
+    AudioAnimatorExcel.AddVoiceHash(builder, VoiceHashOffset);
+    AudioAnimatorExcel.AddAudioClipPath(builder, AudioClipPathOffset);
+    AudioAnimatorExcel.AddAudioPriority(builder, AudioPriority);
+    AudioAnimatorExcel.AddRandomPitchMax(builder, RandomPitchMax);
+    AudioAnimatorExcel.AddRandomPitchMin(builder, RandomPitchMin);
+    AudioAnimatorExcel.AddDelay(builder, Delay);
+    AudioAnimatorExcel.AddVolume(builder, Volume);
+    AudioAnimatorExcel.AddStateName(builder, StateNameOffset);
+    AudioAnimatorExcel.AddStateNameHash(builder, StateNameHash);
+    AudioAnimatorExcel.AddVoiceNamePrefix(builder, VoiceNamePrefixOffset);
+    AudioAnimatorExcel.AddControllerNameHash(builder, ControllerNameHash);
+    AudioAnimatorExcel.AddIgnoreInterruptPlay(builder, IgnoreInterruptPlay);
+    AudioAnimatorExcel.AddIgnoreInterruptDelay(builder, IgnoreInterruptDelay);
+    return AudioAnimatorExcel.EndAudioAnimatorExcel(builder);
+  }
+
+  public static void StartAudioAnimatorExcel(FlatBufferBuilder builder) { builder.StartTable(13); }
+  public static void AddControllerNameHash(FlatBufferBuilder builder, uint controllerNameHash) { builder.AddUint(0, controllerNameHash, 0); }
+  public static void AddVoiceNamePrefix(FlatBufferBuilder builder, StringOffset voiceNamePrefixOffset) { builder.AddOffset(1, voiceNamePrefixOffset.Value, 0); }
+  public static void AddStateNameHash(FlatBufferBuilder builder, uint stateNameHash) { builder.AddUint(2, stateNameHash, 0); }
+  public static void AddStateName(FlatBufferBuilder builder, StringOffset stateNameOffset) { builder.AddOffset(3, stateNameOffset.Value, 0); }
+  public static void AddIgnoreInterruptDelay(FlatBufferBuilder builder, bool ignoreInterruptDelay) { builder.AddBool(4, ignoreInterruptDelay, false); }
+  public static void AddIgnoreInterruptPlay(FlatBufferBuilder builder, bool ignoreInterruptPlay) { builder.AddBool(5, ignoreInterruptPlay, false); }
+  public static void AddVolume(FlatBufferBuilder builder, float volume) { builder.AddFloat(6, volume, 0.0f); }
+  public static void AddDelay(FlatBufferBuilder builder, float delay) { builder.AddFloat(7, delay, 0.0f); }
+  public static void AddRandomPitchMin(FlatBufferBuilder builder, int randomPitchMin) { builder.AddInt(8, randomPitchMin, 0); }
+  public static void AddRandomPitchMax(FlatBufferBuilder builder, int randomPitchMax) { builder.AddInt(9, randomPitchMax, 0); }
+  public static void AddAudioPriority(FlatBufferBuilder builder, int audioPriority) { builder.AddInt(10, audioPriority, 0); }
+  public static void AddAudioClipPath(FlatBufferBuilder builder, VectorOffset audioClipPathOffset) { builder.AddOffset(11, audioClipPathOffset.Value, 0); }
+  public static VectorOffset CreateAudioClipPathVector(FlatBufferBuilder builder, StringOffset[] 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 CreateAudioClipPathVectorBlock(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateAudioClipPathVectorBlock(FlatBufferBuilder builder, ArraySegment<StringOffset> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateAudioClipPathVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<StringOffset>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartAudioClipPathVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddVoiceHash(FlatBufferBuilder builder, VectorOffset voiceHashOffset) { builder.AddOffset(12, voiceHashOffset.Value, 0); }
+  public static VectorOffset CreateVoiceHashVector(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddUint(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateVoiceHashVectorBlock(FlatBufferBuilder builder, uint[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateVoiceHashVectorBlock(FlatBufferBuilder builder, ArraySegment<uint> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateVoiceHashVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<uint>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartVoiceHashVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.AudioAnimatorExcel> EndAudioAnimatorExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.AudioAnimatorExcel>(o);
+  }
+}
+
+
+static public class AudioAnimatorExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*ControllerNameHash*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyString(tablePos, 6 /*VoiceNamePrefix*/, false)
+      && verifier.VerifyField(tablePos, 8 /*StateNameHash*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyString(tablePos, 10 /*StateName*/, false)
+      && verifier.VerifyField(tablePos, 12 /*IgnoreInterruptDelay*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 14 /*IgnoreInterruptPlay*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 16 /*Volume*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 18 /*Delay*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 20 /*RandomPitchMin*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 22 /*RandomPitchMax*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 24 /*AudioPriority*/, 4 /*int*/, 4, false)
+      && verifier.VerifyVectorOfStrings(tablePos, 26 /*AudioClipPath*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 28 /*VoiceHash*/, 4 /*uint*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BGMExcel.cs

@@ -0,0 +1,163 @@
+// <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 BGMExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static BGMExcel GetRootAsBGMExcel(ByteBuffer _bb) { return GetRootAsBGMExcel(_bb, new BGMExcel()); }
+  public static BGMExcel GetRootAsBGMExcel(ByteBuffer _bb, BGMExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public BGMExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long Id { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.Nation Nation_(int j) { int o = __p.__offset(6); return o != 0 ? (SCHALE.Common.FlatData.Nation)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.Nation)0; }
+  public int Nation_Length { get { int o = __p.__offset(6); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<SCHALE.Common.FlatData.Nation> GetNation_Bytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.Nation>(6, 4); }
+#else
+  public ArraySegment<byte>? GetNation_Bytes() { return __p.__vector_as_arraysegment(6); }
+#endif
+  public SCHALE.Common.FlatData.Nation[] GetNation_Array() { int o = __p.__offset(6); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.Nation[] a = new SCHALE.Common.FlatData.Nation[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.Nation)__p.bb.GetInt(p + i * 4); } return a; }
+  public string Path(int j) { int o = __p.__offset(8); return o != 0 ? __p.__string(__p.__vector(o) + j * 4) : null; }
+  public int PathLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public float Volume(int j) { int o = __p.__offset(10); return o != 0 ? __p.bb.GetFloat(__p.__vector(o) + j * 4) : (float)0; }
+  public int VolumeLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<float> GetVolumeBytes() { return __p.__vector_as_span<float>(10, 4); }
+#else
+  public ArraySegment<byte>? GetVolumeBytes() { return __p.__vector_as_arraysegment(10); }
+#endif
+  public float[] GetVolumeArray() { return __p.__vector_as_array<float>(10); }
+  public float LoopStartTime(int j) { int o = __p.__offset(12); return o != 0 ? __p.bb.GetFloat(__p.__vector(o) + j * 4) : (float)0; }
+  public int LoopStartTimeLength { get { int o = __p.__offset(12); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<float> GetLoopStartTimeBytes() { return __p.__vector_as_span<float>(12, 4); }
+#else
+  public ArraySegment<byte>? GetLoopStartTimeBytes() { return __p.__vector_as_arraysegment(12); }
+#endif
+  public float[] GetLoopStartTimeArray() { return __p.__vector_as_array<float>(12); }
+  public float LoopEndTime(int j) { int o = __p.__offset(14); return o != 0 ? __p.bb.GetFloat(__p.__vector(o) + j * 4) : (float)0; }
+  public int LoopEndTimeLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<float> GetLoopEndTimeBytes() { return __p.__vector_as_span<float>(14, 4); }
+#else
+  public ArraySegment<byte>? GetLoopEndTimeBytes() { return __p.__vector_as_arraysegment(14); }
+#endif
+  public float[] GetLoopEndTimeArray() { return __p.__vector_as_array<float>(14); }
+  public float LoopTranstionTime(int j) { int o = __p.__offset(16); return o != 0 ? __p.bb.GetFloat(__p.__vector(o) + j * 4) : (float)0; }
+  public int LoopTranstionTimeLength { get { int o = __p.__offset(16); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<float> GetLoopTranstionTimeBytes() { return __p.__vector_as_span<float>(16, 4); }
+#else
+  public ArraySegment<byte>? GetLoopTranstionTimeBytes() { return __p.__vector_as_arraysegment(16); }
+#endif
+  public float[] GetLoopTranstionTimeArray() { return __p.__vector_as_array<float>(16); }
+  public float LoopOffsetTime(int j) { int o = __p.__offset(18); return o != 0 ? __p.bb.GetFloat(__p.__vector(o) + j * 4) : (float)0; }
+  public int LoopOffsetTimeLength { get { int o = __p.__offset(18); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<float> GetLoopOffsetTimeBytes() { return __p.__vector_as_span<float>(18, 4); }
+#else
+  public ArraySegment<byte>? GetLoopOffsetTimeBytes() { return __p.__vector_as_arraysegment(18); }
+#endif
+  public float[] GetLoopOffsetTimeArray() { return __p.__vector_as_array<float>(18); }
+
+  public static Offset<SCHALE.Common.FlatData.BGMExcel> CreateBGMExcel(FlatBufferBuilder builder,
+      long Id = 0,
+      VectorOffset Nation_Offset = default(VectorOffset),
+      VectorOffset PathOffset = default(VectorOffset),
+      VectorOffset VolumeOffset = default(VectorOffset),
+      VectorOffset LoopStartTimeOffset = default(VectorOffset),
+      VectorOffset LoopEndTimeOffset = default(VectorOffset),
+      VectorOffset LoopTranstionTimeOffset = default(VectorOffset),
+      VectorOffset LoopOffsetTimeOffset = default(VectorOffset)) {
+    builder.StartTable(8);
+    BGMExcel.AddId(builder, Id);
+    BGMExcel.AddLoopOffsetTime(builder, LoopOffsetTimeOffset);
+    BGMExcel.AddLoopTranstionTime(builder, LoopTranstionTimeOffset);
+    BGMExcel.AddLoopEndTime(builder, LoopEndTimeOffset);
+    BGMExcel.AddLoopStartTime(builder, LoopStartTimeOffset);
+    BGMExcel.AddVolume(builder, VolumeOffset);
+    BGMExcel.AddPath(builder, PathOffset);
+    BGMExcel.AddNation_(builder, Nation_Offset);
+    return BGMExcel.EndBGMExcel(builder);
+  }
+
+  public static void StartBGMExcel(FlatBufferBuilder builder) { builder.StartTable(8); }
+  public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
+  public static void AddNation_(FlatBufferBuilder builder, VectorOffset nation_Offset) { builder.AddOffset(1, nation_Offset.Value, 0); }
+  public static VectorOffset CreateNation_Vector(FlatBufferBuilder builder, SCHALE.Common.FlatData.Nation[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt((int)data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateNation_VectorBlock(FlatBufferBuilder builder, SCHALE.Common.FlatData.Nation[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateNation_VectorBlock(FlatBufferBuilder builder, ArraySegment<SCHALE.Common.FlatData.Nation> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateNation_VectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<SCHALE.Common.FlatData.Nation>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartNation_Vector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddPath(FlatBufferBuilder builder, VectorOffset pathOffset) { builder.AddOffset(2, pathOffset.Value, 0); }
+  public static VectorOffset CreatePathVector(FlatBufferBuilder builder, StringOffset[] 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 CreatePathVectorBlock(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreatePathVectorBlock(FlatBufferBuilder builder, ArraySegment<StringOffset> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreatePathVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<StringOffset>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartPathVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddVolume(FlatBufferBuilder builder, VectorOffset volumeOffset) { builder.AddOffset(3, volumeOffset.Value, 0); }
+  public static VectorOffset CreateVolumeVector(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddFloat(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateVolumeVectorBlock(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateVolumeVectorBlock(FlatBufferBuilder builder, ArraySegment<float> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateVolumeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<float>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartVolumeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddLoopStartTime(FlatBufferBuilder builder, VectorOffset loopStartTimeOffset) { builder.AddOffset(4, loopStartTimeOffset.Value, 0); }
+  public static VectorOffset CreateLoopStartTimeVector(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddFloat(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateLoopStartTimeVectorBlock(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateLoopStartTimeVectorBlock(FlatBufferBuilder builder, ArraySegment<float> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateLoopStartTimeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<float>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartLoopStartTimeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddLoopEndTime(FlatBufferBuilder builder, VectorOffset loopEndTimeOffset) { builder.AddOffset(5, loopEndTimeOffset.Value, 0); }
+  public static VectorOffset CreateLoopEndTimeVector(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddFloat(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateLoopEndTimeVectorBlock(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateLoopEndTimeVectorBlock(FlatBufferBuilder builder, ArraySegment<float> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateLoopEndTimeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<float>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartLoopEndTimeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddLoopTranstionTime(FlatBufferBuilder builder, VectorOffset loopTranstionTimeOffset) { builder.AddOffset(6, loopTranstionTimeOffset.Value, 0); }
+  public static VectorOffset CreateLoopTranstionTimeVector(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddFloat(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateLoopTranstionTimeVectorBlock(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateLoopTranstionTimeVectorBlock(FlatBufferBuilder builder, ArraySegment<float> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateLoopTranstionTimeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<float>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartLoopTranstionTimeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddLoopOffsetTime(FlatBufferBuilder builder, VectorOffset loopOffsetTimeOffset) { builder.AddOffset(7, loopOffsetTimeOffset.Value, 0); }
+  public static VectorOffset CreateLoopOffsetTimeVector(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddFloat(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateLoopOffsetTimeVectorBlock(FlatBufferBuilder builder, float[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateLoopOffsetTimeVectorBlock(FlatBufferBuilder builder, ArraySegment<float> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateLoopOffsetTimeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<float>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartLoopOffsetTimeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.BGMExcel> EndBGMExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.BGMExcel>(o);
+  }
+}
+
+
+static public class BGMExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 6 /*Nation_*/, 4 /*SCHALE.Common.FlatData.Nation*/, false)
+      && verifier.VerifyVectorOfStrings(tablePos, 8 /*Path*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 10 /*Volume*/, 4 /*float*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 12 /*LoopStartTime*/, 4 /*float*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 14 /*LoopEndTime*/, 4 /*float*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 16 /*LoopTranstionTime*/, 4 /*float*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 18 /*LoopOffsetTime*/, 4 /*float*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BGMRaidExcel.cs

@@ -0,0 +1,60 @@
+// <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 BGMRaidExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static BGMRaidExcel GetRootAsBGMRaidExcel(ByteBuffer _bb) { return GetRootAsBGMRaidExcel(_bb, new BGMRaidExcel()); }
+  public static BGMRaidExcel GetRootAsBGMRaidExcel(ByteBuffer _bb, BGMRaidExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public BGMRaidExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long StageId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long PhaseIndex { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long BGMId { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+
+  public static Offset<SCHALE.Common.FlatData.BGMRaidExcel> CreateBGMRaidExcel(FlatBufferBuilder builder,
+      long StageId = 0,
+      long PhaseIndex = 0,
+      long BGMId = 0) {
+    builder.StartTable(3);
+    BGMRaidExcel.AddBGMId(builder, BGMId);
+    BGMRaidExcel.AddPhaseIndex(builder, PhaseIndex);
+    BGMRaidExcel.AddStageId(builder, StageId);
+    return BGMRaidExcel.EndBGMRaidExcel(builder);
+  }
+
+  public static void StartBGMRaidExcel(FlatBufferBuilder builder) { builder.StartTable(3); }
+  public static void AddStageId(FlatBufferBuilder builder, long stageId) { builder.AddLong(0, stageId, 0); }
+  public static void AddPhaseIndex(FlatBufferBuilder builder, long phaseIndex) { builder.AddLong(1, phaseIndex, 0); }
+  public static void AddBGMId(FlatBufferBuilder builder, long bGMId) { builder.AddLong(2, bGMId, 0); }
+  public static Offset<SCHALE.Common.FlatData.BGMRaidExcel> EndBGMRaidExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.BGMRaidExcel>(o);
+  }
+}
+
+
+static public class BGMRaidExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*StageId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*PhaseIndex*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*BGMId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BGMUIExcel.cs

@@ -0,0 +1,70 @@
+// <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 BGMUIExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static BGMUIExcel GetRootAsBGMUIExcel(ByteBuffer _bb) { return GetRootAsBGMUIExcel(_bb, new BGMUIExcel()); }
+  public static BGMUIExcel GetRootAsBGMUIExcel(ByteBuffer _bb, BGMUIExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public BGMUIExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public uint UIPrefab { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public long BGMId { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long BGMId2nd { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long BGMId3rd { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long EventContentId { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+
+  public static Offset<SCHALE.Common.FlatData.BGMUIExcel> CreateBGMUIExcel(FlatBufferBuilder builder,
+      uint UIPrefab = 0,
+      long BGMId = 0,
+      long BGMId2nd = 0,
+      long BGMId3rd = 0,
+      long EventContentId = 0) {
+    builder.StartTable(5);
+    BGMUIExcel.AddEventContentId(builder, EventContentId);
+    BGMUIExcel.AddBGMId3rd(builder, BGMId3rd);
+    BGMUIExcel.AddBGMId2nd(builder, BGMId2nd);
+    BGMUIExcel.AddBGMId(builder, BGMId);
+    BGMUIExcel.AddUIPrefab(builder, UIPrefab);
+    return BGMUIExcel.EndBGMUIExcel(builder);
+  }
+
+  public static void StartBGMUIExcel(FlatBufferBuilder builder) { builder.StartTable(5); }
+  public static void AddUIPrefab(FlatBufferBuilder builder, uint uIPrefab) { builder.AddUint(0, uIPrefab, 0); }
+  public static void AddBGMId(FlatBufferBuilder builder, long bGMId) { builder.AddLong(1, bGMId, 0); }
+  public static void AddBGMId2nd(FlatBufferBuilder builder, long bGMId2nd) { builder.AddLong(2, bGMId2nd, 0); }
+  public static void AddBGMId3rd(FlatBufferBuilder builder, long bGMId3rd) { builder.AddLong(3, bGMId3rd, 0); }
+  public static void AddEventContentId(FlatBufferBuilder builder, long eventContentId) { builder.AddLong(4, eventContentId, 0); }
+  public static Offset<SCHALE.Common.FlatData.BGMUIExcel> EndBGMUIExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.BGMUIExcel>(o);
+  }
+}
+
+
+static public class BGMUIExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*UIPrefab*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*BGMId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*BGMId2nd*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*BGMId3rd*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 12 /*EventContentId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BattleCalculationStat.cs

@@ -0,0 +1,18 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum BattleCalculationStat : int
+{
+  FinalDamage = 0,
+  FinalHeal = 1,
+  FinalDamageRatio = 2,
+  FinalDamageRatio2 = 3,
+  FinalCriticalRate = 4,
+};
+
+
+}

SCHALE.Common/FlatData/BattleLevelFactorExcel.cs

@@ -0,0 +1,55 @@
+// <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 BattleLevelFactorExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static BattleLevelFactorExcel GetRootAsBattleLevelFactorExcel(ByteBuffer _bb) { return GetRootAsBattleLevelFactorExcel(_bb, new BattleLevelFactorExcel()); }
+  public static BattleLevelFactorExcel GetRootAsBattleLevelFactorExcel(ByteBuffer _bb, BattleLevelFactorExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public BattleLevelFactorExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public int LevelDiff { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public long DamageRate { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+
+  public static Offset<SCHALE.Common.FlatData.BattleLevelFactorExcel> CreateBattleLevelFactorExcel(FlatBufferBuilder builder,
+      int LevelDiff = 0,
+      long DamageRate = 0) {
+    builder.StartTable(2);
+    BattleLevelFactorExcel.AddDamageRate(builder, DamageRate);
+    BattleLevelFactorExcel.AddLevelDiff(builder, LevelDiff);
+    return BattleLevelFactorExcel.EndBattleLevelFactorExcel(builder);
+  }
+
+  public static void StartBattleLevelFactorExcel(FlatBufferBuilder builder) { builder.StartTable(2); }
+  public static void AddLevelDiff(FlatBufferBuilder builder, int levelDiff) { builder.AddInt(0, levelDiff, 0); }
+  public static void AddDamageRate(FlatBufferBuilder builder, long damageRate) { builder.AddLong(1, damageRate, 0); }
+  public static Offset<SCHALE.Common.FlatData.BattleLevelFactorExcel> EndBattleLevelFactorExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.BattleLevelFactorExcel>(o);
+  }
+}
+
+
+static public class BattleLevelFactorExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*LevelDiff*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*DamageRate*/, 8 /*long*/, 8, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BattleLevelFactorExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 BattleLevelFactorExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static BattleLevelFactorExcelTable GetRootAsBattleLevelFactorExcelTable(ByteBuffer _bb) { return GetRootAsBattleLevelFactorExcelTable(_bb, new BattleLevelFactorExcelTable()); }
+  public static BattleLevelFactorExcelTable GetRootAsBattleLevelFactorExcelTable(ByteBuffer _bb, BattleLevelFactorExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public BattleLevelFactorExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.BattleLevelFactorExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.BattleLevelFactorExcel?)(new SCHALE.Common.FlatData.BattleLevelFactorExcel()).__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.BattleLevelFactorExcelTable> CreateBattleLevelFactorExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    BattleLevelFactorExcelTable.AddDataList(builder, DataListOffset);
+    return BattleLevelFactorExcelTable.EndBattleLevelFactorExcelTable(builder);
+  }
+
+  public static void StartBattleLevelFactorExcelTable(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.BattleLevelFactorExcel>[] 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.BattleLevelFactorExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.BattleLevelFactorExcel>> 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.BattleLevelFactorExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.BattleLevelFactorExcelTable> EndBattleLevelFactorExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.BattleLevelFactorExcelTable>(o);
+  }
+}
+
+
+static public class BattleLevelFactorExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.BattleLevelFactorExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BillingTransactionEndType.cs

@@ -0,0 +1,16 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum BillingTransactionEndType : int
+{
+  None = 0,
+  Success = 1,
+  Cancel = 2,
+};
+
+
+}

SCHALE.Common/FlatData/BlendData.cs

@@ -0,0 +1,61 @@
+// <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 BlendData : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static BlendData GetRootAsBlendData(ByteBuffer _bb) { return GetRootAsBlendData(_bb, new BlendData()); }
+  public static BlendData GetRootAsBlendData(ByteBuffer _bb, BlendData obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public BlendData __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public int Type { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public SCHALE.Common.FlatData.BlendInfo? InfoList(int j) { int o = __p.__offset(6); return o != 0 ? (SCHALE.Common.FlatData.BlendInfo?)(new SCHALE.Common.FlatData.BlendInfo()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int InfoListLength { get { int o = __p.__offset(6); return o != 0 ? __p.__vector_len(o) : 0; } }
+
+  public static Offset<SCHALE.Common.FlatData.BlendData> CreateBlendData(FlatBufferBuilder builder,
+      int Type = 0,
+      VectorOffset InfoListOffset = default(VectorOffset)) {
+    builder.StartTable(2);
+    BlendData.AddInfoList(builder, InfoListOffset);
+    BlendData.AddType(builder, Type);
+    return BlendData.EndBlendData(builder);
+  }
+
+  public static void StartBlendData(FlatBufferBuilder builder) { builder.StartTable(2); }
+  public static void AddType(FlatBufferBuilder builder, int type) { builder.AddInt(0, type, 0); }
+  public static void AddInfoList(FlatBufferBuilder builder, VectorOffset infoListOffset) { builder.AddOffset(1, infoListOffset.Value, 0); }
+  public static VectorOffset CreateInfoListVector(FlatBufferBuilder builder, Offset<SCHALE.Common.FlatData.BlendInfo>[] 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 CreateInfoListVectorBlock(FlatBufferBuilder builder, Offset<SCHALE.Common.FlatData.BlendInfo>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateInfoListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.BlendInfo>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateInfoListVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<SCHALE.Common.FlatData.BlendInfo>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartInfoListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.BlendData> EndBlendData(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.BlendData>(o);
+  }
+}
+
+
+static public class BlendDataVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Type*/, 4 /*int*/, 4, false)
+      && verifier.VerifyVectorOfTables(tablePos, 6 /*InfoList*/, SCHALE.Common.FlatData.BlendInfoVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BlendInfo.cs

@@ -0,0 +1,60 @@
+// <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 BlendInfo : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static BlendInfo GetRootAsBlendInfo(ByteBuffer _bb) { return GetRootAsBlendInfo(_bb, new BlendInfo()); }
+  public static BlendInfo GetRootAsBlendInfo(ByteBuffer _bb, BlendInfo obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public BlendInfo __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public int From { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public int To { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public float Blend { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+
+  public static Offset<SCHALE.Common.FlatData.BlendInfo> CreateBlendInfo(FlatBufferBuilder builder,
+      int From = 0,
+      int To = 0,
+      float Blend = 0.0f) {
+    builder.StartTable(3);
+    BlendInfo.AddBlend(builder, Blend);
+    BlendInfo.AddTo(builder, To);
+    BlendInfo.AddFrom(builder, From);
+    return BlendInfo.EndBlendInfo(builder);
+  }
+
+  public static void StartBlendInfo(FlatBufferBuilder builder) { builder.StartTable(3); }
+  public static void AddFrom(FlatBufferBuilder builder, int from) { builder.AddInt(0, from, 0); }
+  public static void AddTo(FlatBufferBuilder builder, int to) { builder.AddInt(1, to, 0); }
+  public static void AddBlend(FlatBufferBuilder builder, float blend) { builder.AddFloat(2, blend, 0.0f); }
+  public static Offset<SCHALE.Common.FlatData.BlendInfo> EndBlendInfo(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.BlendInfo>(o);
+  }
+}
+
+
+static public class BlendInfoVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*From*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*To*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*Blend*/, 4 /*float*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BossExternalBTExcel.cs

@@ -0,0 +1,97 @@
+// <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 BossExternalBTExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static BossExternalBTExcel GetRootAsBossExternalBTExcel(ByteBuffer _bb) { return GetRootAsBossExternalBTExcel(_bb, new BossExternalBTExcel()); }
+  public static BossExternalBTExcel GetRootAsBossExternalBTExcel(ByteBuffer _bb, BossExternalBTExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public BossExternalBTExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long ExternalBTId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long AIPhase { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.ExternalBTNodeType ExternalBTNodeType { get { int o = __p.__offset(8); return o != 0 ? (SCHALE.Common.FlatData.ExternalBTNodeType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.ExternalBTNodeType.Sequence; } }
+  public SCHALE.Common.FlatData.ExternalBTTrigger ExternalBTTrigger { get { int o = __p.__offset(10); return o != 0 ? (SCHALE.Common.FlatData.ExternalBTTrigger)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.ExternalBTTrigger.None; } }
+  public string TriggerArgument { get { int o = __p.__offset(12); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetTriggerArgumentBytes() { return __p.__vector_as_span<byte>(12, 1); }
+#else
+  public ArraySegment<byte>? GetTriggerArgumentBytes() { return __p.__vector_as_arraysegment(12); }
+#endif
+  public byte[] GetTriggerArgumentArray() { return __p.__vector_as_array<byte>(12); }
+  public long BehaviorRate { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.ExternalBehavior ExternalBehavior { get { int o = __p.__offset(16); return o != 0 ? (SCHALE.Common.FlatData.ExternalBehavior)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.ExternalBehavior.UseNextExSkill; } }
+  public string BehaviorArgument { get { int o = __p.__offset(18); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetBehaviorArgumentBytes() { return __p.__vector_as_span<byte>(18, 1); }
+#else
+  public ArraySegment<byte>? GetBehaviorArgumentBytes() { return __p.__vector_as_arraysegment(18); }
+#endif
+  public byte[] GetBehaviorArgumentArray() { return __p.__vector_as_array<byte>(18); }
+
+  public static Offset<SCHALE.Common.FlatData.BossExternalBTExcel> CreateBossExternalBTExcel(FlatBufferBuilder builder,
+      long ExternalBTId = 0,
+      long AIPhase = 0,
+      SCHALE.Common.FlatData.ExternalBTNodeType ExternalBTNodeType = SCHALE.Common.FlatData.ExternalBTNodeType.Sequence,
+      SCHALE.Common.FlatData.ExternalBTTrigger ExternalBTTrigger = SCHALE.Common.FlatData.ExternalBTTrigger.None,
+      StringOffset TriggerArgumentOffset = default(StringOffset),
+      long BehaviorRate = 0,
+      SCHALE.Common.FlatData.ExternalBehavior ExternalBehavior = SCHALE.Common.FlatData.ExternalBehavior.UseNextExSkill,
+      StringOffset BehaviorArgumentOffset = default(StringOffset)) {
+    builder.StartTable(8);
+    BossExternalBTExcel.AddBehaviorRate(builder, BehaviorRate);
+    BossExternalBTExcel.AddAIPhase(builder, AIPhase);
+    BossExternalBTExcel.AddExternalBTId(builder, ExternalBTId);
+    BossExternalBTExcel.AddBehaviorArgument(builder, BehaviorArgumentOffset);
+    BossExternalBTExcel.AddExternalBehavior(builder, ExternalBehavior);
+    BossExternalBTExcel.AddTriggerArgument(builder, TriggerArgumentOffset);
+    BossExternalBTExcel.AddExternalBTTrigger(builder, ExternalBTTrigger);
+    BossExternalBTExcel.AddExternalBTNodeType(builder, ExternalBTNodeType);
+    return BossExternalBTExcel.EndBossExternalBTExcel(builder);
+  }
+
+  public static void StartBossExternalBTExcel(FlatBufferBuilder builder) { builder.StartTable(8); }
+  public static void AddExternalBTId(FlatBufferBuilder builder, long externalBTId) { builder.AddLong(0, externalBTId, 0); }
+  public static void AddAIPhase(FlatBufferBuilder builder, long aIPhase) { builder.AddLong(1, aIPhase, 0); }
+  public static void AddExternalBTNodeType(FlatBufferBuilder builder, SCHALE.Common.FlatData.ExternalBTNodeType externalBTNodeType) { builder.AddInt(2, (int)externalBTNodeType, 0); }
+  public static void AddExternalBTTrigger(FlatBufferBuilder builder, SCHALE.Common.FlatData.ExternalBTTrigger externalBTTrigger) { builder.AddInt(3, (int)externalBTTrigger, 0); }
+  public static void AddTriggerArgument(FlatBufferBuilder builder, StringOffset triggerArgumentOffset) { builder.AddOffset(4, triggerArgumentOffset.Value, 0); }
+  public static void AddBehaviorRate(FlatBufferBuilder builder, long behaviorRate) { builder.AddLong(5, behaviorRate, 0); }
+  public static void AddExternalBehavior(FlatBufferBuilder builder, SCHALE.Common.FlatData.ExternalBehavior externalBehavior) { builder.AddInt(6, (int)externalBehavior, 0); }
+  public static void AddBehaviorArgument(FlatBufferBuilder builder, StringOffset behaviorArgumentOffset) { builder.AddOffset(7, behaviorArgumentOffset.Value, 0); }
+  public static Offset<SCHALE.Common.FlatData.BossExternalBTExcel> EndBossExternalBTExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.BossExternalBTExcel>(o);
+  }
+}
+
+
+static public class BossExternalBTExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*ExternalBTId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*AIPhase*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*ExternalBTNodeType*/, 4 /*SCHALE.Common.FlatData.ExternalBTNodeType*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*ExternalBTTrigger*/, 4 /*SCHALE.Common.FlatData.ExternalBTTrigger*/, 4, false)
+      && verifier.VerifyString(tablePos, 12 /*TriggerArgument*/, false)
+      && verifier.VerifyField(tablePos, 14 /*BehaviorRate*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 16 /*ExternalBehavior*/, 4 /*SCHALE.Common.FlatData.ExternalBehavior*/, 4, false)
+      && verifier.VerifyString(tablePos, 18 /*BehaviorArgument*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BossExternalBTExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 BossExternalBTExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static BossExternalBTExcelTable GetRootAsBossExternalBTExcelTable(ByteBuffer _bb) { return GetRootAsBossExternalBTExcelTable(_bb, new BossExternalBTExcelTable()); }
+  public static BossExternalBTExcelTable GetRootAsBossExternalBTExcelTable(ByteBuffer _bb, BossExternalBTExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public BossExternalBTExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.BossExternalBTExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.BossExternalBTExcel?)(new SCHALE.Common.FlatData.BossExternalBTExcel()).__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.BossExternalBTExcelTable> CreateBossExternalBTExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    BossExternalBTExcelTable.AddDataList(builder, DataListOffset);
+    return BossExternalBTExcelTable.EndBossExternalBTExcelTable(builder);
+  }
+
+  public static void StartBossExternalBTExcelTable(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.BossExternalBTExcel>[] 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.BossExternalBTExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.BossExternalBTExcel>> 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.BossExternalBTExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.BossExternalBTExcelTable> EndBossExternalBTExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.BossExternalBTExcelTable>(o);
+  }
+}
+
+
+static public class BossExternalBTExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.BossExternalBTExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BossPhaseExcel.cs

@@ -0,0 +1,83 @@
+// <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 BossPhaseExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static BossPhaseExcel GetRootAsBossPhaseExcel(ByteBuffer _bb) { return GetRootAsBossPhaseExcel(_bb, new BossPhaseExcel()); }
+  public static BossPhaseExcel GetRootAsBossPhaseExcel(ByteBuffer _bb, BossPhaseExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public BossPhaseExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long Id { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long AIPhase { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string NormalAttackSkillUniqueName { get { int o = __p.__offset(8); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetNormalAttackSkillUniqueNameBytes() { return __p.__vector_as_span<byte>(8, 1); }
+#else
+  public ArraySegment<byte>? GetNormalAttackSkillUniqueNameBytes() { return __p.__vector_as_arraysegment(8); }
+#endif
+  public byte[] GetNormalAttackSkillUniqueNameArray() { return __p.__vector_as_array<byte>(8); }
+  public bool UseExSkill(int j) { int o = __p.__offset(10); return o != 0 ? 0!=__p.bb.Get(__p.__vector(o) + j * 1) : false; }
+  public int UseExSkillLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<bool> GetUseExSkillBytes() { return __p.__vector_as_span<bool>(10, 1); }
+#else
+  public ArraySegment<byte>? GetUseExSkillBytes() { return __p.__vector_as_arraysegment(10); }
+#endif
+  public bool[] GetUseExSkillArray() { return __p.__vector_as_array<bool>(10); }
+
+  public static Offset<SCHALE.Common.FlatData.BossPhaseExcel> CreateBossPhaseExcel(FlatBufferBuilder builder,
+      long Id = 0,
+      long AIPhase = 0,
+      StringOffset NormalAttackSkillUniqueNameOffset = default(StringOffset),
+      VectorOffset UseExSkillOffset = default(VectorOffset)) {
+    builder.StartTable(4);
+    BossPhaseExcel.AddAIPhase(builder, AIPhase);
+    BossPhaseExcel.AddId(builder, Id);
+    BossPhaseExcel.AddUseExSkill(builder, UseExSkillOffset);
+    BossPhaseExcel.AddNormalAttackSkillUniqueName(builder, NormalAttackSkillUniqueNameOffset);
+    return BossPhaseExcel.EndBossPhaseExcel(builder);
+  }
+
+  public static void StartBossPhaseExcel(FlatBufferBuilder builder) { builder.StartTable(4); }
+  public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
+  public static void AddAIPhase(FlatBufferBuilder builder, long aIPhase) { builder.AddLong(1, aIPhase, 0); }
+  public static void AddNormalAttackSkillUniqueName(FlatBufferBuilder builder, StringOffset normalAttackSkillUniqueNameOffset) { builder.AddOffset(2, normalAttackSkillUniqueNameOffset.Value, 0); }
+  public static void AddUseExSkill(FlatBufferBuilder builder, VectorOffset useExSkillOffset) { builder.AddOffset(3, useExSkillOffset.Value, 0); }
+  public static VectorOffset CreateUseExSkillVector(FlatBufferBuilder builder, bool[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddBool(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateUseExSkillVectorBlock(FlatBufferBuilder builder, bool[] data) { builder.StartVector(1, data.Length, 1); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateUseExSkillVectorBlock(FlatBufferBuilder builder, ArraySegment<bool> data) { builder.StartVector(1, data.Count, 1); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateUseExSkillVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<bool>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartUseExSkillVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); }
+  public static Offset<SCHALE.Common.FlatData.BossPhaseExcel> EndBossPhaseExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.BossPhaseExcel>(o);
+  }
+}
+
+
+static public class BossPhaseExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*AIPhase*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 8 /*NormalAttackSkillUniqueName*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 10 /*UseExSkill*/, 1 /*bool*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BossPhaseExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 BossPhaseExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static BossPhaseExcelTable GetRootAsBossPhaseExcelTable(ByteBuffer _bb) { return GetRootAsBossPhaseExcelTable(_bb, new BossPhaseExcelTable()); }
+  public static BossPhaseExcelTable GetRootAsBossPhaseExcelTable(ByteBuffer _bb, BossPhaseExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public BossPhaseExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.BossPhaseExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.BossPhaseExcel?)(new SCHALE.Common.FlatData.BossPhaseExcel()).__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.BossPhaseExcelTable> CreateBossPhaseExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    BossPhaseExcelTable.AddDataList(builder, DataListOffset);
+    return BossPhaseExcelTable.EndBossPhaseExcelTable(builder);
+  }
+
+  public static void StartBossPhaseExcelTable(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.BossPhaseExcel>[] 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.BossPhaseExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.BossPhaseExcel>> 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.BossPhaseExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.BossPhaseExcelTable> EndBossPhaseExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.BossPhaseExcelTable>(o);
+  }
+}
+
+
+static public class BossPhaseExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.BossPhaseExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BubbleType.cs

@@ -0,0 +1,19 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum BubbleType : int
+{
+  Idle = 0,
+  Monologue = 1,
+  EmoticonNormal = 2,
+  EmoticonFavorite = 3,
+  EmoticonReward = 4,
+  EmoticonGiveGift = 5,
+};
+
+
+}

SCHALE.Common/FlatData/BuffConditionType.cs

@@ -0,0 +1,17 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum BuffConditionType : int
+{
+  All = 0,
+  Character = 1,
+  School = 2,
+  Weapon = 3,
+};
+
+
+}

SCHALE.Common/FlatData/BuffIconType.cs

@@ -0,0 +1,60 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum BuffIconType : int
+{
+  None = 0,
+  Debuff_DyingPenalty = 1,
+  CC_MindControl = 2,
+  CC_Inoperative = 3,
+  CC_Confusion = 4,
+  CC_Provoke = 5,
+  CC_Silence = 6,
+  CC_Blind = 7,
+  Dot_Damage = 8,
+  Dot_Heal = 9,
+  Buff_AttackPower = 10,
+  Buff_CriticalChance = 11,
+  Buff_CriticalDamage = 12,
+  Buff_DefensePower = 13,
+  Buff_Dodge = 14,
+  Buff_Hit = 15,
+  Buff_WeaponRange = 16,
+  Buff_SightRange = 17,
+  Buff_MoveSpeed = 18,
+  Buff_Mind = 19,
+  Debuf_AttackPower = 20,
+  Debuff_CriticalChance = 21,
+  Debuff_CriticalDamage = 22,
+  Debuff_DefensePower = 23,
+  Debuff_Dodge = 24,
+  Debuff_Hit = 25,
+  Debuff_WeaponRange = 26,
+  Debuff_SightRange = 27,
+  Debuff_MoveSpeed = 28,
+  Debuff_Mind = 29,
+  Buff_AttackTime = 30,
+  Debuff_AttackTime = 31,
+  Buff_MaxHp = 32,
+  Debuff_MaxHp = 33,
+  Buff_MaxBulletCount = 34,
+  Debuff_MaxBulletCount = 35,
+  Debuff_SuppliesCondition = 36,
+  Buff_HealEffectivenessRate = 37,
+  Debuff_HealEffectivenessRate = 38,
+  Buff_HealPower = 39,
+  Debuff_HealPower = 40,
+  Buff_CriticalChanceResistPoint = 41,
+  Debuff_CriticalChanceResistPoint = 42,
+  CC_Stunned = 43,
+  Debuff_ConcentratedTarget = 44,
+  Buff_Immortal = 45,
+  Max = 46,
+};
+
+
+}

SCHALE.Common/FlatData/BuffOverlap.cs

@@ -0,0 +1,17 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum BuffOverlap : int
+{
+  Able = 0,
+  Unable = 1,
+  Change = 2,
+  Additive = 3,
+};
+
+
+}

SCHALE.Common/FlatData/BuffParticleExcel.cs

@@ -0,0 +1,94 @@
+// <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 BuffParticleExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static BuffParticleExcel GetRootAsBuffParticleExcel(ByteBuffer _bb) { return GetRootAsBuffParticleExcel(_bb, new BuffParticleExcel()); }
+  public static BuffParticleExcel GetRootAsBuffParticleExcel(ByteBuffer _bb, BuffParticleExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public BuffParticleExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long UniqueId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string UniqueName { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetUniqueNameBytes() { return __p.__vector_as_span<byte>(6, 1); }
+#else
+  public ArraySegment<byte>? GetUniqueNameBytes() { return __p.__vector_as_arraysegment(6); }
+#endif
+  public byte[] GetUniqueNameArray() { return __p.__vector_as_array<byte>(6); }
+  public string BuffType { get { int o = __p.__offset(8); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetBuffTypeBytes() { return __p.__vector_as_span<byte>(8, 1); }
+#else
+  public ArraySegment<byte>? GetBuffTypeBytes() { return __p.__vector_as_arraysegment(8); }
+#endif
+  public byte[] GetBuffTypeArray() { return __p.__vector_as_array<byte>(8); }
+  public string BuffName { get { int o = __p.__offset(10); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetBuffNameBytes() { return __p.__vector_as_span<byte>(10, 1); }
+#else
+  public ArraySegment<byte>? GetBuffNameBytes() { return __p.__vector_as_arraysegment(10); }
+#endif
+  public byte[] GetBuffNameArray() { return __p.__vector_as_array<byte>(10); }
+  public string ResourcePath { get { int o = __p.__offset(12); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetResourcePathBytes() { return __p.__vector_as_span<byte>(12, 1); }
+#else
+  public ArraySegment<byte>? GetResourcePathBytes() { return __p.__vector_as_arraysegment(12); }
+#endif
+  public byte[] GetResourcePathArray() { return __p.__vector_as_array<byte>(12); }
+
+  public static Offset<SCHALE.Common.FlatData.BuffParticleExcel> CreateBuffParticleExcel(FlatBufferBuilder builder,
+      long UniqueId = 0,
+      StringOffset UniqueNameOffset = default(StringOffset),
+      StringOffset BuffTypeOffset = default(StringOffset),
+      StringOffset BuffNameOffset = default(StringOffset),
+      StringOffset ResourcePathOffset = default(StringOffset)) {
+    builder.StartTable(5);
+    BuffParticleExcel.AddUniqueId(builder, UniqueId);
+    BuffParticleExcel.AddResourcePath(builder, ResourcePathOffset);
+    BuffParticleExcel.AddBuffName(builder, BuffNameOffset);
+    BuffParticleExcel.AddBuffType(builder, BuffTypeOffset);
+    BuffParticleExcel.AddUniqueName(builder, UniqueNameOffset);
+    return BuffParticleExcel.EndBuffParticleExcel(builder);
+  }
+
+  public static void StartBuffParticleExcel(FlatBufferBuilder builder) { builder.StartTable(5); }
+  public static void AddUniqueId(FlatBufferBuilder builder, long uniqueId) { builder.AddLong(0, uniqueId, 0); }
+  public static void AddUniqueName(FlatBufferBuilder builder, StringOffset uniqueNameOffset) { builder.AddOffset(1, uniqueNameOffset.Value, 0); }
+  public static void AddBuffType(FlatBufferBuilder builder, StringOffset buffTypeOffset) { builder.AddOffset(2, buffTypeOffset.Value, 0); }
+  public static void AddBuffName(FlatBufferBuilder builder, StringOffset buffNameOffset) { builder.AddOffset(3, buffNameOffset.Value, 0); }
+  public static void AddResourcePath(FlatBufferBuilder builder, StringOffset resourcePathOffset) { builder.AddOffset(4, resourcePathOffset.Value, 0); }
+  public static Offset<SCHALE.Common.FlatData.BuffParticleExcel> EndBuffParticleExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.BuffParticleExcel>(o);
+  }
+}
+
+
+static public class BuffParticleExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*UniqueId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 6 /*UniqueName*/, false)
+      && verifier.VerifyString(tablePos, 8 /*BuffType*/, false)
+      && verifier.VerifyString(tablePos, 10 /*BuffName*/, false)
+      && verifier.VerifyString(tablePos, 12 /*ResourcePath*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BuffParticleExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 BuffParticleExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static BuffParticleExcelTable GetRootAsBuffParticleExcelTable(ByteBuffer _bb) { return GetRootAsBuffParticleExcelTable(_bb, new BuffParticleExcelTable()); }
+  public static BuffParticleExcelTable GetRootAsBuffParticleExcelTable(ByteBuffer _bb, BuffParticleExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public BuffParticleExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.BuffParticleExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.BuffParticleExcel?)(new SCHALE.Common.FlatData.BuffParticleExcel()).__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.BuffParticleExcelTable> CreateBuffParticleExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    BuffParticleExcelTable.AddDataList(builder, DataListOffset);
+    return BuffParticleExcelTable.EndBuffParticleExcelTable(builder);
+  }
+
+  public static void StartBuffParticleExcelTable(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.BuffParticleExcel>[] 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.BuffParticleExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.BuffParticleExcel>> 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.BuffParticleExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.BuffParticleExcelTable> EndBuffParticleExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.BuffParticleExcelTable>(o);
+  }
+}
+
+
+static public class BuffParticleExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.BuffParticleExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BuffType.cs

@@ -0,0 +1,38 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum BuffType : int
+{
+  None = 0,
+  Buff_AttackPower = 1,
+  Buff_CriticalChance = 2,
+  Buff_CriticalDamage = 3,
+  Buff_DefensePower = 4,
+  Buff_Dodge = 5,
+  Buff_Hit = 6,
+  Buff_WeaponRange = 7,
+  Buff_SightRange = 8,
+  Buff_MoveSpeed = 9,
+  Buff_AttackTime = 10,
+  Buff_MaxHp = 11,
+  Buff_MaxBulletCount = 12,
+  DeBuff_AttackPower = 13,
+  DeBuff_CriticalChance = 14,
+  DeBuff_CriticalDamage = 15,
+  DeBuff_DefensePower = 16,
+  DeBuff_Dodge = 17,
+  DeBuff_Hit = 18,
+  DeBuff_WeaponRange = 19,
+  DeBuff_SightRange = 20,
+  DeBuff_MoveSpeed = 21,
+  DeBuff_AttackTime = 22,
+  DeBuff_MaxHp = 23,
+  DeBuff_MaxBulletCount = 24,
+};
+
+
+}

SCHALE.Common/FlatData/BulletArmorDamageFactorExcel.cs

@@ -0,0 +1,91 @@
+// <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 BulletArmorDamageFactorExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static BulletArmorDamageFactorExcel GetRootAsBulletArmorDamageFactorExcel(ByteBuffer _bb) { return GetRootAsBulletArmorDamageFactorExcel(_bb, new BulletArmorDamageFactorExcel()); }
+  public static BulletArmorDamageFactorExcel GetRootAsBulletArmorDamageFactorExcel(ByteBuffer _bb, BulletArmorDamageFactorExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public BulletArmorDamageFactorExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public string DamageFactorGroupId { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetDamageFactorGroupIdBytes() { return __p.__vector_as_span<byte>(4, 1); }
+#else
+  public ArraySegment<byte>? GetDamageFactorGroupIdBytes() { return __p.__vector_as_arraysegment(4); }
+#endif
+  public byte[] GetDamageFactorGroupIdArray() { return __p.__vector_as_array<byte>(4); }
+  public SCHALE.Common.FlatData.BulletType BulletType { get { int o = __p.__offset(6); return o != 0 ? (SCHALE.Common.FlatData.BulletType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.BulletType.Normal; } }
+  public SCHALE.Common.FlatData.ArmorType ArmorType { get { int o = __p.__offset(8); return o != 0 ? (SCHALE.Common.FlatData.ArmorType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.ArmorType.LightArmor; } }
+  public long DamageRate { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.DamageAttribute DamageAttribute { get { int o = __p.__offset(12); return o != 0 ? (SCHALE.Common.FlatData.DamageAttribute)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.DamageAttribute.Resist; } }
+  public long MinDamageRate { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long MaxDamageRate { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public bool ShowHighlightFloater { get { int o = __p.__offset(18); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+
+  public static Offset<SCHALE.Common.FlatData.BulletArmorDamageFactorExcel> CreateBulletArmorDamageFactorExcel(FlatBufferBuilder builder,
+      StringOffset DamageFactorGroupIdOffset = default(StringOffset),
+      SCHALE.Common.FlatData.BulletType BulletType = SCHALE.Common.FlatData.BulletType.Normal,
+      SCHALE.Common.FlatData.ArmorType ArmorType = SCHALE.Common.FlatData.ArmorType.LightArmor,
+      long DamageRate = 0,
+      SCHALE.Common.FlatData.DamageAttribute DamageAttribute = SCHALE.Common.FlatData.DamageAttribute.Resist,
+      long MinDamageRate = 0,
+      long MaxDamageRate = 0,
+      bool ShowHighlightFloater = false) {
+    builder.StartTable(8);
+    BulletArmorDamageFactorExcel.AddMaxDamageRate(builder, MaxDamageRate);
+    BulletArmorDamageFactorExcel.AddMinDamageRate(builder, MinDamageRate);
+    BulletArmorDamageFactorExcel.AddDamageRate(builder, DamageRate);
+    BulletArmorDamageFactorExcel.AddDamageAttribute(builder, DamageAttribute);
+    BulletArmorDamageFactorExcel.AddArmorType(builder, ArmorType);
+    BulletArmorDamageFactorExcel.AddBulletType(builder, BulletType);
+    BulletArmorDamageFactorExcel.AddDamageFactorGroupId(builder, DamageFactorGroupIdOffset);
+    BulletArmorDamageFactorExcel.AddShowHighlightFloater(builder, ShowHighlightFloater);
+    return BulletArmorDamageFactorExcel.EndBulletArmorDamageFactorExcel(builder);
+  }
+
+  public static void StartBulletArmorDamageFactorExcel(FlatBufferBuilder builder) { builder.StartTable(8); }
+  public static void AddDamageFactorGroupId(FlatBufferBuilder builder, StringOffset damageFactorGroupIdOffset) { builder.AddOffset(0, damageFactorGroupIdOffset.Value, 0); }
+  public static void AddBulletType(FlatBufferBuilder builder, SCHALE.Common.FlatData.BulletType bulletType) { builder.AddInt(1, (int)bulletType, 0); }
+  public static void AddArmorType(FlatBufferBuilder builder, SCHALE.Common.FlatData.ArmorType armorType) { builder.AddInt(2, (int)armorType, 0); }
+  public static void AddDamageRate(FlatBufferBuilder builder, long damageRate) { builder.AddLong(3, damageRate, 0); }
+  public static void AddDamageAttribute(FlatBufferBuilder builder, SCHALE.Common.FlatData.DamageAttribute damageAttribute) { builder.AddInt(4, (int)damageAttribute, 0); }
+  public static void AddMinDamageRate(FlatBufferBuilder builder, long minDamageRate) { builder.AddLong(5, minDamageRate, 0); }
+  public static void AddMaxDamageRate(FlatBufferBuilder builder, long maxDamageRate) { builder.AddLong(6, maxDamageRate, 0); }
+  public static void AddShowHighlightFloater(FlatBufferBuilder builder, bool showHighlightFloater) { builder.AddBool(7, showHighlightFloater, false); }
+  public static Offset<SCHALE.Common.FlatData.BulletArmorDamageFactorExcel> EndBulletArmorDamageFactorExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.BulletArmorDamageFactorExcel>(o);
+  }
+}
+
+
+static public class BulletArmorDamageFactorExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyString(tablePos, 4 /*DamageFactorGroupId*/, false)
+      && verifier.VerifyField(tablePos, 6 /*BulletType*/, 4 /*SCHALE.Common.FlatData.BulletType*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*ArmorType*/, 4 /*SCHALE.Common.FlatData.ArmorType*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*DamageRate*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 12 /*DamageAttribute*/, 4 /*SCHALE.Common.FlatData.DamageAttribute*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*MinDamageRate*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 16 /*MaxDamageRate*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 18 /*ShowHighlightFloater*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BulletArmorDamageFactorExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 BulletArmorDamageFactorExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static BulletArmorDamageFactorExcelTable GetRootAsBulletArmorDamageFactorExcelTable(ByteBuffer _bb) { return GetRootAsBulletArmorDamageFactorExcelTable(_bb, new BulletArmorDamageFactorExcelTable()); }
+  public static BulletArmorDamageFactorExcelTable GetRootAsBulletArmorDamageFactorExcelTable(ByteBuffer _bb, BulletArmorDamageFactorExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public BulletArmorDamageFactorExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.BulletArmorDamageFactorExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.BulletArmorDamageFactorExcel?)(new SCHALE.Common.FlatData.BulletArmorDamageFactorExcel()).__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.BulletArmorDamageFactorExcelTable> CreateBulletArmorDamageFactorExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    BulletArmorDamageFactorExcelTable.AddDataList(builder, DataListOffset);
+    return BulletArmorDamageFactorExcelTable.EndBulletArmorDamageFactorExcelTable(builder);
+  }
+
+  public static void StartBulletArmorDamageFactorExcelTable(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.BulletArmorDamageFactorExcel>[] 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.BulletArmorDamageFactorExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.BulletArmorDamageFactorExcel>> 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.BulletArmorDamageFactorExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.BulletArmorDamageFactorExcelTable> EndBulletArmorDamageFactorExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.BulletArmorDamageFactorExcelTable>(o);
+  }
+}
+
+
+static public class BulletArmorDamageFactorExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.BulletArmorDamageFactorExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/BulletType.cs

@@ -0,0 +1,20 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum BulletType : int
+{
+  Normal = 0,
+  Pierce = 1,
+  Explosion = 2,
+  Siege = 3,
+  Mystic = 4,
+  None = 5,
+  Sonic = 6,
+};
+
+
+}

SCHALE.Common/FlatData/CVCollectionType.cs

@@ -0,0 +1,16 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum CVCollectionType : int
+{
+  CVNormal = 0,
+  CVEvent = 1,
+  CVEtc = 2,
+};
+
+
+}

SCHALE.Common/FlatData/CVExceptionTarget.cs

@@ -0,0 +1,15 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum CVExceptionTarget : int
+{
+  CharacterId = 0,
+  SquadType = 1,
+};
+
+
+}

SCHALE.Common/FlatData/CVPrintType.cs

@@ -0,0 +1,16 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum CVPrintType : int
+{
+  CharacterOverwrite = 0,
+  PrefabOverwrite = 1,
+  Add = 2,
+};
+
+
+}

SCHALE.Common/FlatData/CafeCharacterState.cs

@@ -0,0 +1,19 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum CafeCharacterState : int
+{
+  None = 0,
+  Idle = 1,
+  Walk = 2,
+  Reaction = 3,
+  Interaction = 4,
+  Max = 5,
+};
+
+
+}

SCHALE.Common/FlatData/CafeInfoExcel.cs

@@ -0,0 +1,65 @@
+// <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 CafeInfoExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static CafeInfoExcel GetRootAsCafeInfoExcel(ByteBuffer _bb) { return GetRootAsCafeInfoExcel(_bb, new CafeInfoExcel()); }
+  public static CafeInfoExcel GetRootAsCafeInfoExcel(ByteBuffer _bb, CafeInfoExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public CafeInfoExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long CafeId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public bool IsDefault { get { int o = __p.__offset(6); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public SCHALE.Common.FlatData.OpenConditionContent OpenConditionCafeId { get { int o = __p.__offset(8); return o != 0 ? (SCHALE.Common.FlatData.OpenConditionContent)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.OpenConditionContent.Shop; } }
+  public SCHALE.Common.FlatData.OpenConditionContent OpenConditionCafeInvite { get { int o = __p.__offset(10); return o != 0 ? (SCHALE.Common.FlatData.OpenConditionContent)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.OpenConditionContent.Shop; } }
+
+  public static Offset<SCHALE.Common.FlatData.CafeInfoExcel> CreateCafeInfoExcel(FlatBufferBuilder builder,
+      long CafeId = 0,
+      bool IsDefault = false,
+      SCHALE.Common.FlatData.OpenConditionContent OpenConditionCafeId = SCHALE.Common.FlatData.OpenConditionContent.Shop,
+      SCHALE.Common.FlatData.OpenConditionContent OpenConditionCafeInvite = SCHALE.Common.FlatData.OpenConditionContent.Shop) {
+    builder.StartTable(4);
+    CafeInfoExcel.AddCafeId(builder, CafeId);
+    CafeInfoExcel.AddOpenConditionCafeInvite(builder, OpenConditionCafeInvite);
+    CafeInfoExcel.AddOpenConditionCafeId(builder, OpenConditionCafeId);
+    CafeInfoExcel.AddIsDefault(builder, IsDefault);
+    return CafeInfoExcel.EndCafeInfoExcel(builder);
+  }
+
+  public static void StartCafeInfoExcel(FlatBufferBuilder builder) { builder.StartTable(4); }
+  public static void AddCafeId(FlatBufferBuilder builder, long cafeId) { builder.AddLong(0, cafeId, 0); }
+  public static void AddIsDefault(FlatBufferBuilder builder, bool isDefault) { builder.AddBool(1, isDefault, false); }
+  public static void AddOpenConditionCafeId(FlatBufferBuilder builder, SCHALE.Common.FlatData.OpenConditionContent openConditionCafeId) { builder.AddInt(2, (int)openConditionCafeId, 0); }
+  public static void AddOpenConditionCafeInvite(FlatBufferBuilder builder, SCHALE.Common.FlatData.OpenConditionContent openConditionCafeInvite) { builder.AddInt(3, (int)openConditionCafeInvite, 0); }
+  public static Offset<SCHALE.Common.FlatData.CafeInfoExcel> EndCafeInfoExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.CafeInfoExcel>(o);
+  }
+}
+
+
+static public class CafeInfoExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*CafeId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*IsDefault*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 8 /*OpenConditionCafeId*/, 4 /*SCHALE.Common.FlatData.OpenConditionContent*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*OpenConditionCafeInvite*/, 4 /*SCHALE.Common.FlatData.OpenConditionContent*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/CafeInfoExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 CafeInfoExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static CafeInfoExcelTable GetRootAsCafeInfoExcelTable(ByteBuffer _bb) { return GetRootAsCafeInfoExcelTable(_bb, new CafeInfoExcelTable()); }
+  public static CafeInfoExcelTable GetRootAsCafeInfoExcelTable(ByteBuffer _bb, CafeInfoExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public CafeInfoExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.CafeInfoExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.CafeInfoExcel?)(new SCHALE.Common.FlatData.CafeInfoExcel()).__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.CafeInfoExcelTable> CreateCafeInfoExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    CafeInfoExcelTable.AddDataList(builder, DataListOffset);
+    return CafeInfoExcelTable.EndCafeInfoExcelTable(builder);
+  }
+
+  public static void StartCafeInfoExcelTable(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.CafeInfoExcel>[] 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.CafeInfoExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.CafeInfoExcel>> 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.CafeInfoExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.CafeInfoExcelTable> EndCafeInfoExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.CafeInfoExcelTable>(o);
+  }
+}
+
+
+static public class CafeInfoExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.CafeInfoExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/CafeInteractionExcel.cs

@@ -0,0 +1,137 @@
+// <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 CafeInteractionExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static CafeInteractionExcel GetRootAsCafeInteractionExcel(ByteBuffer _bb) { return GetRootAsCafeInteractionExcel(_bb, new CafeInteractionExcel()); }
+  public static CafeInteractionExcel GetRootAsCafeInteractionExcel(ByteBuffer _bb, CafeInteractionExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public CafeInteractionExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long CharacterId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public bool IgnoreIfUnobtained { get { int o = __p.__offset(6); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public string IgnoreIfUnobtainedStartDate { get { int o = __p.__offset(8); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetIgnoreIfUnobtainedStartDateBytes() { return __p.__vector_as_span<byte>(8, 1); }
+#else
+  public ArraySegment<byte>? GetIgnoreIfUnobtainedStartDateBytes() { return __p.__vector_as_arraysegment(8); }
+#endif
+  public byte[] GetIgnoreIfUnobtainedStartDateArray() { return __p.__vector_as_array<byte>(8); }
+  public string IgnoreIfUnobtainedEndDate { get { int o = __p.__offset(10); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetIgnoreIfUnobtainedEndDateBytes() { return __p.__vector_as_span<byte>(10, 1); }
+#else
+  public ArraySegment<byte>? GetIgnoreIfUnobtainedEndDateBytes() { return __p.__vector_as_arraysegment(10); }
+#endif
+  public byte[] GetIgnoreIfUnobtainedEndDateArray() { return __p.__vector_as_array<byte>(10); }
+  public SCHALE.Common.FlatData.BubbleType BubbleType_(int j) { int o = __p.__offset(12); return o != 0 ? (SCHALE.Common.FlatData.BubbleType)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.BubbleType)0; }
+  public int BubbleType_Length { get { int o = __p.__offset(12); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<SCHALE.Common.FlatData.BubbleType> GetBubbleType_Bytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.BubbleType>(12, 4); }
+#else
+  public ArraySegment<byte>? GetBubbleType_Bytes() { return __p.__vector_as_arraysegment(12); }
+#endif
+  public SCHALE.Common.FlatData.BubbleType[] GetBubbleType_Array() { int o = __p.__offset(12); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.BubbleType[] a = new SCHALE.Common.FlatData.BubbleType[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.BubbleType)__p.bb.GetInt(p + i * 4); } return a; }
+  public long BubbleDuration(int j) { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int BubbleDurationLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetBubbleDurationBytes() { return __p.__vector_as_span<long>(14, 8); }
+#else
+  public ArraySegment<byte>? GetBubbleDurationBytes() { return __p.__vector_as_arraysegment(14); }
+#endif
+  public long[] GetBubbleDurationArray() { return __p.__vector_as_array<long>(14); }
+  public SCHALE.Common.FlatData.ParcelType FavorEmoticonRewardParcelType { get { int o = __p.__offset(16); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.ParcelType.None; } }
+  public long FavorEmoticonRewardId { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long FavorEmoticonRewardAmount { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string CafeCharacterState(int j) { int o = __p.__offset(22); return o != 0 ? __p.__string(__p.__vector(o) + j * 4) : null; }
+  public int CafeCharacterStateLength { get { int o = __p.__offset(22); return o != 0 ? __p.__vector_len(o) : 0; } }
+
+  public static Offset<SCHALE.Common.FlatData.CafeInteractionExcel> CreateCafeInteractionExcel(FlatBufferBuilder builder,
+      long CharacterId = 0,
+      bool IgnoreIfUnobtained = false,
+      StringOffset IgnoreIfUnobtainedStartDateOffset = default(StringOffset),
+      StringOffset IgnoreIfUnobtainedEndDateOffset = default(StringOffset),
+      VectorOffset BubbleType_Offset = default(VectorOffset),
+      VectorOffset BubbleDurationOffset = default(VectorOffset),
+      SCHALE.Common.FlatData.ParcelType FavorEmoticonRewardParcelType = SCHALE.Common.FlatData.ParcelType.None,
+      long FavorEmoticonRewardId = 0,
+      long FavorEmoticonRewardAmount = 0,
+      VectorOffset CafeCharacterStateOffset = default(VectorOffset)) {
+    builder.StartTable(10);
+    CafeInteractionExcel.AddFavorEmoticonRewardAmount(builder, FavorEmoticonRewardAmount);
+    CafeInteractionExcel.AddFavorEmoticonRewardId(builder, FavorEmoticonRewardId);
+    CafeInteractionExcel.AddCharacterId(builder, CharacterId);
+    CafeInteractionExcel.AddCafeCharacterState(builder, CafeCharacterStateOffset);
+    CafeInteractionExcel.AddFavorEmoticonRewardParcelType(builder, FavorEmoticonRewardParcelType);
+    CafeInteractionExcel.AddBubbleDuration(builder, BubbleDurationOffset);
+    CafeInteractionExcel.AddBubbleType_(builder, BubbleType_Offset);
+    CafeInteractionExcel.AddIgnoreIfUnobtainedEndDate(builder, IgnoreIfUnobtainedEndDateOffset);
+    CafeInteractionExcel.AddIgnoreIfUnobtainedStartDate(builder, IgnoreIfUnobtainedStartDateOffset);
+    CafeInteractionExcel.AddIgnoreIfUnobtained(builder, IgnoreIfUnobtained);
+    return CafeInteractionExcel.EndCafeInteractionExcel(builder);
+  }
+
+  public static void StartCafeInteractionExcel(FlatBufferBuilder builder) { builder.StartTable(10); }
+  public static void AddCharacterId(FlatBufferBuilder builder, long characterId) { builder.AddLong(0, characterId, 0); }
+  public static void AddIgnoreIfUnobtained(FlatBufferBuilder builder, bool ignoreIfUnobtained) { builder.AddBool(1, ignoreIfUnobtained, false); }
+  public static void AddIgnoreIfUnobtainedStartDate(FlatBufferBuilder builder, StringOffset ignoreIfUnobtainedStartDateOffset) { builder.AddOffset(2, ignoreIfUnobtainedStartDateOffset.Value, 0); }
+  public static void AddIgnoreIfUnobtainedEndDate(FlatBufferBuilder builder, StringOffset ignoreIfUnobtainedEndDateOffset) { builder.AddOffset(3, ignoreIfUnobtainedEndDateOffset.Value, 0); }
+  public static void AddBubbleType_(FlatBufferBuilder builder, VectorOffset bubbleType_Offset) { builder.AddOffset(4, bubbleType_Offset.Value, 0); }
+  public static VectorOffset CreateBubbleType_Vector(FlatBufferBuilder builder, SCHALE.Common.FlatData.BubbleType[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt((int)data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateBubbleType_VectorBlock(FlatBufferBuilder builder, SCHALE.Common.FlatData.BubbleType[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateBubbleType_VectorBlock(FlatBufferBuilder builder, ArraySegment<SCHALE.Common.FlatData.BubbleType> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateBubbleType_VectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<SCHALE.Common.FlatData.BubbleType>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartBubbleType_Vector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddBubbleDuration(FlatBufferBuilder builder, VectorOffset bubbleDurationOffset) { builder.AddOffset(5, bubbleDurationOffset.Value, 0); }
+  public static VectorOffset CreateBubbleDurationVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateBubbleDurationVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateBubbleDurationVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateBubbleDurationVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartBubbleDurationVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddFavorEmoticonRewardParcelType(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType favorEmoticonRewardParcelType) { builder.AddInt(6, (int)favorEmoticonRewardParcelType, 0); }
+  public static void AddFavorEmoticonRewardId(FlatBufferBuilder builder, long favorEmoticonRewardId) { builder.AddLong(7, favorEmoticonRewardId, 0); }
+  public static void AddFavorEmoticonRewardAmount(FlatBufferBuilder builder, long favorEmoticonRewardAmount) { builder.AddLong(8, favorEmoticonRewardAmount, 0); }
+  public static void AddCafeCharacterState(FlatBufferBuilder builder, VectorOffset cafeCharacterStateOffset) { builder.AddOffset(9, cafeCharacterStateOffset.Value, 0); }
+  public static VectorOffset CreateCafeCharacterStateVector(FlatBufferBuilder builder, StringOffset[] 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 CreateCafeCharacterStateVectorBlock(FlatBufferBuilder builder, StringOffset[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCafeCharacterStateVectorBlock(FlatBufferBuilder builder, ArraySegment<StringOffset> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCafeCharacterStateVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<StringOffset>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartCafeCharacterStateVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.CafeInteractionExcel> EndCafeInteractionExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.CafeInteractionExcel>(o);
+  }
+}
+
+
+static public class CafeInteractionExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*CharacterId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*IgnoreIfUnobtained*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyString(tablePos, 8 /*IgnoreIfUnobtainedStartDate*/, false)
+      && verifier.VerifyString(tablePos, 10 /*IgnoreIfUnobtainedEndDate*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 12 /*BubbleType_*/, 4 /*SCHALE.Common.FlatData.BubbleType*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 14 /*BubbleDuration*/, 8 /*long*/, false)
+      && verifier.VerifyField(tablePos, 16 /*FavorEmoticonRewardParcelType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, 4, false)
+      && verifier.VerifyField(tablePos, 18 /*FavorEmoticonRewardId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 20 /*FavorEmoticonRewardAmount*/, 8 /*long*/, 8, false)
+      && verifier.VerifyVectorOfStrings(tablePos, 22 /*CafeCharacterState*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/CafeInteractionExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 CafeInteractionExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static CafeInteractionExcelTable GetRootAsCafeInteractionExcelTable(ByteBuffer _bb) { return GetRootAsCafeInteractionExcelTable(_bb, new CafeInteractionExcelTable()); }
+  public static CafeInteractionExcelTable GetRootAsCafeInteractionExcelTable(ByteBuffer _bb, CafeInteractionExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public CafeInteractionExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.CafeInteractionExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.CafeInteractionExcel?)(new SCHALE.Common.FlatData.CafeInteractionExcel()).__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.CafeInteractionExcelTable> CreateCafeInteractionExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    CafeInteractionExcelTable.AddDataList(builder, DataListOffset);
+    return CafeInteractionExcelTable.EndCafeInteractionExcelTable(builder);
+  }
+
+  public static void StartCafeInteractionExcelTable(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.CafeInteractionExcel>[] 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.CafeInteractionExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.CafeInteractionExcel>> 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.CafeInteractionExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.CafeInteractionExcelTable> EndCafeInteractionExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.CafeInteractionExcelTable>(o);
+  }
+}
+
+
+static public class CafeInteractionExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.CafeInteractionExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/CafeProductionExcel.cs

@@ -0,0 +1,80 @@
+// <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 CafeProductionExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static CafeProductionExcel GetRootAsCafeProductionExcel(ByteBuffer _bb) { return GetRootAsCafeProductionExcel(_bb, new CafeProductionExcel()); }
+  public static CafeProductionExcel GetRootAsCafeProductionExcel(ByteBuffer _bb, CafeProductionExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public CafeProductionExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long CafeId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long Rank { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.ParcelType CafeProductionParcelType { get { int o = __p.__offset(8); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.ParcelType.None; } }
+  public long CafeProductionParcelId { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long ParcelProductionCoefficient { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long ParcelProductionCorrectionValue { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long ParcelStorageMax { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+
+  public static Offset<SCHALE.Common.FlatData.CafeProductionExcel> CreateCafeProductionExcel(FlatBufferBuilder builder,
+      long CafeId = 0,
+      long Rank = 0,
+      SCHALE.Common.FlatData.ParcelType CafeProductionParcelType = SCHALE.Common.FlatData.ParcelType.None,
+      long CafeProductionParcelId = 0,
+      long ParcelProductionCoefficient = 0,
+      long ParcelProductionCorrectionValue = 0,
+      long ParcelStorageMax = 0) {
+    builder.StartTable(7);
+    CafeProductionExcel.AddParcelStorageMax(builder, ParcelStorageMax);
+    CafeProductionExcel.AddParcelProductionCorrectionValue(builder, ParcelProductionCorrectionValue);
+    CafeProductionExcel.AddParcelProductionCoefficient(builder, ParcelProductionCoefficient);
+    CafeProductionExcel.AddCafeProductionParcelId(builder, CafeProductionParcelId);
+    CafeProductionExcel.AddRank(builder, Rank);
+    CafeProductionExcel.AddCafeId(builder, CafeId);
+    CafeProductionExcel.AddCafeProductionParcelType(builder, CafeProductionParcelType);
+    return CafeProductionExcel.EndCafeProductionExcel(builder);
+  }
+
+  public static void StartCafeProductionExcel(FlatBufferBuilder builder) { builder.StartTable(7); }
+  public static void AddCafeId(FlatBufferBuilder builder, long cafeId) { builder.AddLong(0, cafeId, 0); }
+  public static void AddRank(FlatBufferBuilder builder, long rank) { builder.AddLong(1, rank, 0); }
+  public static void AddCafeProductionParcelType(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType cafeProductionParcelType) { builder.AddInt(2, (int)cafeProductionParcelType, 0); }
+  public static void AddCafeProductionParcelId(FlatBufferBuilder builder, long cafeProductionParcelId) { builder.AddLong(3, cafeProductionParcelId, 0); }
+  public static void AddParcelProductionCoefficient(FlatBufferBuilder builder, long parcelProductionCoefficient) { builder.AddLong(4, parcelProductionCoefficient, 0); }
+  public static void AddParcelProductionCorrectionValue(FlatBufferBuilder builder, long parcelProductionCorrectionValue) { builder.AddLong(5, parcelProductionCorrectionValue, 0); }
+  public static void AddParcelStorageMax(FlatBufferBuilder builder, long parcelStorageMax) { builder.AddLong(6, parcelStorageMax, 0); }
+  public static Offset<SCHALE.Common.FlatData.CafeProductionExcel> EndCafeProductionExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.CafeProductionExcel>(o);
+  }
+}
+
+
+static public class CafeProductionExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*CafeId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*Rank*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*CafeProductionParcelType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*CafeProductionParcelId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 12 /*ParcelProductionCoefficient*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 14 /*ParcelProductionCorrectionValue*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 16 /*ParcelStorageMax*/, 8 /*long*/, 8, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/CafeProductionExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 CafeProductionExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static CafeProductionExcelTable GetRootAsCafeProductionExcelTable(ByteBuffer _bb) { return GetRootAsCafeProductionExcelTable(_bb, new CafeProductionExcelTable()); }
+  public static CafeProductionExcelTable GetRootAsCafeProductionExcelTable(ByteBuffer _bb, CafeProductionExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public CafeProductionExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.CafeProductionExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.CafeProductionExcel?)(new SCHALE.Common.FlatData.CafeProductionExcel()).__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.CafeProductionExcelTable> CreateCafeProductionExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    CafeProductionExcelTable.AddDataList(builder, DataListOffset);
+    return CafeProductionExcelTable.EndCafeProductionExcelTable(builder);
+  }
+
+  public static void StartCafeProductionExcelTable(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.CafeProductionExcel>[] 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.CafeProductionExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.CafeProductionExcel>> 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.CafeProductionExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.CafeProductionExcelTable> EndCafeProductionExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.CafeProductionExcelTable>(o);
+  }
+}
+
+
+static public class CafeProductionExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.CafeProductionExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/CafeRankExcel.cs

@@ -0,0 +1,119 @@
+// <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 CafeRankExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static CafeRankExcel GetRootAsCafeRankExcel(ByteBuffer _bb) { return GetRootAsCafeRankExcel(_bb, new CafeRankExcel()); }
+  public static CafeRankExcel GetRootAsCafeRankExcel(ByteBuffer _bb, CafeRankExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public CafeRankExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long CafeId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long Rank { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long RecipeId { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long ComfortMax { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long TagCountMax { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public int CharacterVisitMin { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public int CharacterVisitMax { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public int CafeVisitWeightBase { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public int CafeVisitWeightTagBonusStep(int j) { int o = __p.__offset(20); return o != 0 ? __p.bb.GetInt(__p.__vector(o) + j * 4) : (int)0; }
+  public int CafeVisitWeightTagBonusStepLength { get { int o = __p.__offset(20); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<int> GetCafeVisitWeightTagBonusStepBytes() { return __p.__vector_as_span<int>(20, 4); }
+#else
+  public ArraySegment<byte>? GetCafeVisitWeightTagBonusStepBytes() { return __p.__vector_as_arraysegment(20); }
+#endif
+  public int[] GetCafeVisitWeightTagBonusStepArray() { return __p.__vector_as_array<int>(20); }
+  public int CafeVisitWeightTagBonus(int j) { int o = __p.__offset(22); return o != 0 ? __p.bb.GetInt(__p.__vector(o) + j * 4) : (int)0; }
+  public int CafeVisitWeightTagBonusLength { get { int o = __p.__offset(22); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<int> GetCafeVisitWeightTagBonusBytes() { return __p.__vector_as_span<int>(22, 4); }
+#else
+  public ArraySegment<byte>? GetCafeVisitWeightTagBonusBytes() { return __p.__vector_as_arraysegment(22); }
+#endif
+  public int[] GetCafeVisitWeightTagBonusArray() { return __p.__vector_as_array<int>(22); }
+
+  public static Offset<SCHALE.Common.FlatData.CafeRankExcel> CreateCafeRankExcel(FlatBufferBuilder builder,
+      long CafeId = 0,
+      long Rank = 0,
+      long RecipeId = 0,
+      long ComfortMax = 0,
+      long TagCountMax = 0,
+      int CharacterVisitMin = 0,
+      int CharacterVisitMax = 0,
+      int CafeVisitWeightBase = 0,
+      VectorOffset CafeVisitWeightTagBonusStepOffset = default(VectorOffset),
+      VectorOffset CafeVisitWeightTagBonusOffset = default(VectorOffset)) {
+    builder.StartTable(10);
+    CafeRankExcel.AddTagCountMax(builder, TagCountMax);
+    CafeRankExcel.AddComfortMax(builder, ComfortMax);
+    CafeRankExcel.AddRecipeId(builder, RecipeId);
+    CafeRankExcel.AddRank(builder, Rank);
+    CafeRankExcel.AddCafeId(builder, CafeId);
+    CafeRankExcel.AddCafeVisitWeightTagBonus(builder, CafeVisitWeightTagBonusOffset);
+    CafeRankExcel.AddCafeVisitWeightTagBonusStep(builder, CafeVisitWeightTagBonusStepOffset);
+    CafeRankExcel.AddCafeVisitWeightBase(builder, CafeVisitWeightBase);
+    CafeRankExcel.AddCharacterVisitMax(builder, CharacterVisitMax);
+    CafeRankExcel.AddCharacterVisitMin(builder, CharacterVisitMin);
+    return CafeRankExcel.EndCafeRankExcel(builder);
+  }
+
+  public static void StartCafeRankExcel(FlatBufferBuilder builder) { builder.StartTable(10); }
+  public static void AddCafeId(FlatBufferBuilder builder, long cafeId) { builder.AddLong(0, cafeId, 0); }
+  public static void AddRank(FlatBufferBuilder builder, long rank) { builder.AddLong(1, rank, 0); }
+  public static void AddRecipeId(FlatBufferBuilder builder, long recipeId) { builder.AddLong(2, recipeId, 0); }
+  public static void AddComfortMax(FlatBufferBuilder builder, long comfortMax) { builder.AddLong(3, comfortMax, 0); }
+  public static void AddTagCountMax(FlatBufferBuilder builder, long tagCountMax) { builder.AddLong(4, tagCountMax, 0); }
+  public static void AddCharacterVisitMin(FlatBufferBuilder builder, int characterVisitMin) { builder.AddInt(5, characterVisitMin, 0); }
+  public static void AddCharacterVisitMax(FlatBufferBuilder builder, int characterVisitMax) { builder.AddInt(6, characterVisitMax, 0); }
+  public static void AddCafeVisitWeightBase(FlatBufferBuilder builder, int cafeVisitWeightBase) { builder.AddInt(7, cafeVisitWeightBase, 0); }
+  public static void AddCafeVisitWeightTagBonusStep(FlatBufferBuilder builder, VectorOffset cafeVisitWeightTagBonusStepOffset) { builder.AddOffset(8, cafeVisitWeightTagBonusStepOffset.Value, 0); }
+  public static VectorOffset CreateCafeVisitWeightTagBonusStepVector(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateCafeVisitWeightTagBonusStepVectorBlock(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCafeVisitWeightTagBonusStepVectorBlock(FlatBufferBuilder builder, ArraySegment<int> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCafeVisitWeightTagBonusStepVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<int>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartCafeVisitWeightTagBonusStepVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddCafeVisitWeightTagBonus(FlatBufferBuilder builder, VectorOffset cafeVisitWeightTagBonusOffset) { builder.AddOffset(9, cafeVisitWeightTagBonusOffset.Value, 0); }
+  public static VectorOffset CreateCafeVisitWeightTagBonusVector(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateCafeVisitWeightTagBonusVectorBlock(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCafeVisitWeightTagBonusVectorBlock(FlatBufferBuilder builder, ArraySegment<int> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCafeVisitWeightTagBonusVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<int>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartCafeVisitWeightTagBonusVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.CafeRankExcel> EndCafeRankExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.CafeRankExcel>(o);
+  }
+}
+
+
+static public class CafeRankExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*CafeId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*Rank*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 8 /*RecipeId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*ComfortMax*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 12 /*TagCountMax*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 14 /*CharacterVisitMin*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 16 /*CharacterVisitMax*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 18 /*CafeVisitWeightBase*/, 4 /*int*/, 4, false)
+      && verifier.VerifyVectorOfData(tablePos, 20 /*CafeVisitWeightTagBonusStep*/, 4 /*int*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 22 /*CafeVisitWeightTagBonus*/, 4 /*int*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/CafeRankExcelTable.cs

@@ -0,0 +1,56 @@
+// <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 CafeRankExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static CafeRankExcelTable GetRootAsCafeRankExcelTable(ByteBuffer _bb) { return GetRootAsCafeRankExcelTable(_bb, new CafeRankExcelTable()); }
+  public static CafeRankExcelTable GetRootAsCafeRankExcelTable(ByteBuffer _bb, CafeRankExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public CafeRankExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.CafeRankExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.CafeRankExcel?)(new SCHALE.Common.FlatData.CafeRankExcel()).__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.CafeRankExcelTable> CreateCafeRankExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    CafeRankExcelTable.AddDataList(builder, DataListOffset);
+    return CafeRankExcelTable.EndCafeRankExcelTable(builder);
+  }
+
+  public static void StartCafeRankExcelTable(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.CafeRankExcel>[] 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.CafeRankExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.CafeRankExcel>> 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.CafeRankExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.CafeRankExcelTable> EndCafeRankExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.CafeRankExcelTable>(o);
+  }
+}
+
+
+static public class CafeRankExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.CafeRankExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/CameraExcel.cs

@@ -0,0 +1,100 @@
+// <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 CameraExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static CameraExcel GetRootAsCameraExcel(ByteBuffer _bb) { return GetRootAsCameraExcel(_bb, new CameraExcel()); }
+  public static CameraExcel GetRootAsCameraExcel(ByteBuffer _bb, CameraExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public CameraExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long UniqueId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public float MinDistance { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public float MaxDistance { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public float RotationX { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public float RotationY { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public bool MoveInstantly { get { int o = __p.__offset(14); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public bool MoveInstantlyRotationSave { get { int o = __p.__offset(16); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public float LeftMargin { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public float BottomMargin { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public bool IgnoreEnemies { get { int o = __p.__offset(22); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public bool UseRailPointCompensation { get { int o = __p.__offset(24); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+
+  public static Offset<SCHALE.Common.FlatData.CameraExcel> CreateCameraExcel(FlatBufferBuilder builder,
+      long UniqueId = 0,
+      float MinDistance = 0.0f,
+      float MaxDistance = 0.0f,
+      float RotationX = 0.0f,
+      float RotationY = 0.0f,
+      bool MoveInstantly = false,
+      bool MoveInstantlyRotationSave = false,
+      float LeftMargin = 0.0f,
+      float BottomMargin = 0.0f,
+      bool IgnoreEnemies = false,
+      bool UseRailPointCompensation = false) {
+    builder.StartTable(11);
+    CameraExcel.AddUniqueId(builder, UniqueId);
+    CameraExcel.AddBottomMargin(builder, BottomMargin);
+    CameraExcel.AddLeftMargin(builder, LeftMargin);
+    CameraExcel.AddRotationY(builder, RotationY);
+    CameraExcel.AddRotationX(builder, RotationX);
+    CameraExcel.AddMaxDistance(builder, MaxDistance);
+    CameraExcel.AddMinDistance(builder, MinDistance);
+    CameraExcel.AddUseRailPointCompensation(builder, UseRailPointCompensation);
+    CameraExcel.AddIgnoreEnemies(builder, IgnoreEnemies);
+    CameraExcel.AddMoveInstantlyRotationSave(builder, MoveInstantlyRotationSave);
+    CameraExcel.AddMoveInstantly(builder, MoveInstantly);
+    return CameraExcel.EndCameraExcel(builder);
+  }
+
+  public static void StartCameraExcel(FlatBufferBuilder builder) { builder.StartTable(11); }
+  public static void AddUniqueId(FlatBufferBuilder builder, long uniqueId) { builder.AddLong(0, uniqueId, 0); }
+  public static void AddMinDistance(FlatBufferBuilder builder, float minDistance) { builder.AddFloat(1, minDistance, 0.0f); }
+  public static void AddMaxDistance(FlatBufferBuilder builder, float maxDistance) { builder.AddFloat(2, maxDistance, 0.0f); }
+  public static void AddRotationX(FlatBufferBuilder builder, float rotationX) { builder.AddFloat(3, rotationX, 0.0f); }
+  public static void AddRotationY(FlatBufferBuilder builder, float rotationY) { builder.AddFloat(4, rotationY, 0.0f); }
+  public static void AddMoveInstantly(FlatBufferBuilder builder, bool moveInstantly) { builder.AddBool(5, moveInstantly, false); }
+  public static void AddMoveInstantlyRotationSave(FlatBufferBuilder builder, bool moveInstantlyRotationSave) { builder.AddBool(6, moveInstantlyRotationSave, false); }
+  public static void AddLeftMargin(FlatBufferBuilder builder, float leftMargin) { builder.AddFloat(7, leftMargin, 0.0f); }
+  public static void AddBottomMargin(FlatBufferBuilder builder, float bottomMargin) { builder.AddFloat(8, bottomMargin, 0.0f); }
+  public static void AddIgnoreEnemies(FlatBufferBuilder builder, bool ignoreEnemies) { builder.AddBool(9, ignoreEnemies, false); }
+  public static void AddUseRailPointCompensation(FlatBufferBuilder builder, bool useRailPointCompensation) { builder.AddBool(10, useRailPointCompensation, false); }
+  public static Offset<SCHALE.Common.FlatData.CameraExcel> EndCameraExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.CameraExcel>(o);
+  }
+}
+
+
+static public class CameraExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*UniqueId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*MinDistance*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*MaxDistance*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*RotationX*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 12 /*RotationY*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*MoveInstantly*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 16 /*MoveInstantlyRotationSave*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 18 /*LeftMargin*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 20 /*BottomMargin*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 22 /*IgnoreEnemies*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 24 /*UseRailPointCompensation*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/CameraExcelTable.cs

@@ -0,0 +1,56 @@
+// <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

@@ -0,0 +1,193 @@
+// <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 CampaignChapterExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static CampaignChapterExcel GetRootAsCampaignChapterExcel(ByteBuffer _bb) { return GetRootAsCampaignChapterExcel(_bb, new CampaignChapterExcel()); }
+  public static CampaignChapterExcel GetRootAsCampaignChapterExcel(ByteBuffer _bb, CampaignChapterExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public CampaignChapterExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long Id { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string Name { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetNameBytes() { return __p.__vector_as_span<byte>(6, 1); }
+#else
+  public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(6); }
+#endif
+  public byte[] GetNameArray() { return __p.__vector_as_array<byte>(6); }
+  public string NormalImagePath { get { int o = __p.__offset(8); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetNormalImagePathBytes() { return __p.__vector_as_span<byte>(8, 1); }
+#else
+  public ArraySegment<byte>? GetNormalImagePathBytes() { return __p.__vector_as_arraysegment(8); }
+#endif
+  public byte[] GetNormalImagePathArray() { return __p.__vector_as_array<byte>(8); }
+  public string HardImagePath { get { int o = __p.__offset(10); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetHardImagePathBytes() { return __p.__vector_as_span<byte>(10, 1); }
+#else
+  public ArraySegment<byte>? GetHardImagePathBytes() { return __p.__vector_as_arraysegment(10); }
+#endif
+  public byte[] GetHardImagePathArray() { return __p.__vector_as_array<byte>(10); }
+  public long Order { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long PreChapterId(int j) { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int PreChapterIdLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetPreChapterIdBytes() { return __p.__vector_as_span<long>(14, 8); }
+#else
+  public ArraySegment<byte>? GetPreChapterIdBytes() { return __p.__vector_as_arraysegment(14); }
+#endif
+  public long[] GetPreChapterIdArray() { return __p.__vector_as_array<long>(14); }
+  public long ChapterRewardId { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long ChapterHardRewardId { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long ChapterVeryHardRewardId { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long NormalCampaignStageId(int j) { int o = __p.__offset(22); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int NormalCampaignStageIdLength { get { int o = __p.__offset(22); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetNormalCampaignStageIdBytes() { return __p.__vector_as_span<long>(22, 8); }
+#else
+  public ArraySegment<byte>? GetNormalCampaignStageIdBytes() { return __p.__vector_as_arraysegment(22); }
+#endif
+  public long[] GetNormalCampaignStageIdArray() { return __p.__vector_as_array<long>(22); }
+  public long NormalExtraStageId(int j) { int o = __p.__offset(24); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int NormalExtraStageIdLength { get { int o = __p.__offset(24); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetNormalExtraStageIdBytes() { return __p.__vector_as_span<long>(24, 8); }
+#else
+  public ArraySegment<byte>? GetNormalExtraStageIdBytes() { return __p.__vector_as_arraysegment(24); }
+#endif
+  public long[] GetNormalExtraStageIdArray() { return __p.__vector_as_array<long>(24); }
+  public long HardCampaignStageId(int j) { int o = __p.__offset(26); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int HardCampaignStageIdLength { get { int o = __p.__offset(26); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetHardCampaignStageIdBytes() { return __p.__vector_as_span<long>(26, 8); }
+#else
+  public ArraySegment<byte>? GetHardCampaignStageIdBytes() { return __p.__vector_as_arraysegment(26); }
+#endif
+  public long[] GetHardCampaignStageIdArray() { return __p.__vector_as_array<long>(26); }
+  public long VeryHardCampaignStageId(int j) { int o = __p.__offset(28); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int VeryHardCampaignStageIdLength { get { int o = __p.__offset(28); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetVeryHardCampaignStageIdBytes() { return __p.__vector_as_span<long>(28, 8); }
+#else
+  public ArraySegment<byte>? GetVeryHardCampaignStageIdBytes() { return __p.__vector_as_arraysegment(28); }
+#endif
+  public long[] GetVeryHardCampaignStageIdArray() { return __p.__vector_as_array<long>(28); }
+  public bool IsTacticSkip { get { int o = __p.__offset(30); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+
+  public static Offset<SCHALE.Common.FlatData.CampaignChapterExcel> CreateCampaignChapterExcel(FlatBufferBuilder builder,
+      long Id = 0,
+      StringOffset NameOffset = default(StringOffset),
+      StringOffset NormalImagePathOffset = default(StringOffset),
+      StringOffset HardImagePathOffset = default(StringOffset),
+      long Order = 0,
+      VectorOffset PreChapterIdOffset = default(VectorOffset),
+      long ChapterRewardId = 0,
+      long ChapterHardRewardId = 0,
+      long ChapterVeryHardRewardId = 0,
+      VectorOffset NormalCampaignStageIdOffset = default(VectorOffset),
+      VectorOffset NormalExtraStageIdOffset = default(VectorOffset),
+      VectorOffset HardCampaignStageIdOffset = default(VectorOffset),
+      VectorOffset VeryHardCampaignStageIdOffset = default(VectorOffset),
+      bool IsTacticSkip = false) {
+    builder.StartTable(14);
+    CampaignChapterExcel.AddChapterVeryHardRewardId(builder, ChapterVeryHardRewardId);
+    CampaignChapterExcel.AddChapterHardRewardId(builder, ChapterHardRewardId);
+    CampaignChapterExcel.AddChapterRewardId(builder, ChapterRewardId);
+    CampaignChapterExcel.AddOrder(builder, Order);
+    CampaignChapterExcel.AddId(builder, Id);
+    CampaignChapterExcel.AddVeryHardCampaignStageId(builder, VeryHardCampaignStageIdOffset);
+    CampaignChapterExcel.AddHardCampaignStageId(builder, HardCampaignStageIdOffset);
+    CampaignChapterExcel.AddNormalExtraStageId(builder, NormalExtraStageIdOffset);
+    CampaignChapterExcel.AddNormalCampaignStageId(builder, NormalCampaignStageIdOffset);
+    CampaignChapterExcel.AddPreChapterId(builder, PreChapterIdOffset);
+    CampaignChapterExcel.AddHardImagePath(builder, HardImagePathOffset);
+    CampaignChapterExcel.AddNormalImagePath(builder, NormalImagePathOffset);
+    CampaignChapterExcel.AddName(builder, NameOffset);
+    CampaignChapterExcel.AddIsTacticSkip(builder, IsTacticSkip);
+    return CampaignChapterExcel.EndCampaignChapterExcel(builder);
+  }
+
+  public static void StartCampaignChapterExcel(FlatBufferBuilder builder) { builder.StartTable(14); }
+  public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
+  public static void AddName(FlatBufferBuilder builder, StringOffset nameOffset) { builder.AddOffset(1, nameOffset.Value, 0); }
+  public static void AddNormalImagePath(FlatBufferBuilder builder, StringOffset normalImagePathOffset) { builder.AddOffset(2, normalImagePathOffset.Value, 0); }
+  public static void AddHardImagePath(FlatBufferBuilder builder, StringOffset hardImagePathOffset) { builder.AddOffset(3, hardImagePathOffset.Value, 0); }
+  public static void AddOrder(FlatBufferBuilder builder, long order) { builder.AddLong(4, order, 0); }
+  public static void AddPreChapterId(FlatBufferBuilder builder, VectorOffset preChapterIdOffset) { builder.AddOffset(5, preChapterIdOffset.Value, 0); }
+  public static VectorOffset CreatePreChapterIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreatePreChapterIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreatePreChapterIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreatePreChapterIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartPreChapterIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddChapterRewardId(FlatBufferBuilder builder, long chapterRewardId) { builder.AddLong(6, chapterRewardId, 0); }
+  public static void AddChapterHardRewardId(FlatBufferBuilder builder, long chapterHardRewardId) { builder.AddLong(7, chapterHardRewardId, 0); }
+  public static void AddChapterVeryHardRewardId(FlatBufferBuilder builder, long chapterVeryHardRewardId) { builder.AddLong(8, chapterVeryHardRewardId, 0); }
+  public static void AddNormalCampaignStageId(FlatBufferBuilder builder, VectorOffset normalCampaignStageIdOffset) { builder.AddOffset(9, normalCampaignStageIdOffset.Value, 0); }
+  public static VectorOffset CreateNormalCampaignStageIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateNormalCampaignStageIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateNormalCampaignStageIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateNormalCampaignStageIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartNormalCampaignStageIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddNormalExtraStageId(FlatBufferBuilder builder, VectorOffset normalExtraStageIdOffset) { builder.AddOffset(10, normalExtraStageIdOffset.Value, 0); }
+  public static VectorOffset CreateNormalExtraStageIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateNormalExtraStageIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateNormalExtraStageIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateNormalExtraStageIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartNormalExtraStageIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddHardCampaignStageId(FlatBufferBuilder builder, VectorOffset hardCampaignStageIdOffset) { builder.AddOffset(11, hardCampaignStageIdOffset.Value, 0); }
+  public static VectorOffset CreateHardCampaignStageIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateHardCampaignStageIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateHardCampaignStageIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateHardCampaignStageIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartHardCampaignStageIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddVeryHardCampaignStageId(FlatBufferBuilder builder, VectorOffset veryHardCampaignStageIdOffset) { builder.AddOffset(12, veryHardCampaignStageIdOffset.Value, 0); }
+  public static VectorOffset CreateVeryHardCampaignStageIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateVeryHardCampaignStageIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateVeryHardCampaignStageIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateVeryHardCampaignStageIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartVeryHardCampaignStageIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddIsTacticSkip(FlatBufferBuilder builder, bool isTacticSkip) { builder.AddBool(13, isTacticSkip, false); }
+  public static Offset<SCHALE.Common.FlatData.CampaignChapterExcel> EndCampaignChapterExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.CampaignChapterExcel>(o);
+  }
+}
+
+
+static public class CampaignChapterExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 6 /*Name*/, false)
+      && verifier.VerifyString(tablePos, 8 /*NormalImagePath*/, false)
+      && verifier.VerifyString(tablePos, 10 /*HardImagePath*/, false)
+      && verifier.VerifyField(tablePos, 12 /*Order*/, 8 /*long*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 14 /*PreChapterId*/, 8 /*long*/, false)
+      && verifier.VerifyField(tablePos, 16 /*ChapterRewardId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 18 /*ChapterHardRewardId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 20 /*ChapterVeryHardRewardId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 22 /*NormalCampaignStageId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 24 /*NormalExtraStageId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 26 /*HardCampaignStageId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 28 /*VeryHardCampaignStageId*/, 8 /*long*/, false)
+      && verifier.VerifyField(tablePos, 30 /*IsTacticSkip*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}