private static void \uE01A(object \uE049, ref \uE017 \uE04A, Stream \uE04B)
{
if (CpInazumaMsgPack.\uE005 == CpCustomDataPackMode.Array)
{
CpInazumaMsgPack.\uE00B(\uE04A.\uE001.Count, CpInazumaMsgPack.\uE007(\uE04A.\uE001.Count), \uE04B);
}
if (CpInazumaMsgPack.\uE005 == CpCustomDataPackMode.Raw || CpInazumaMsgPack.\uE005 == CpCustomDataPackMode.Array)
{
for (int i = 0; i < \uE04A.\uE001.Count; i++)
{
\uE016 uE = \uE04A.\uE001[i];
CpInazumaMsgPack.Pack(uE.\uE002.GetValue(\uE049), \uE04B);
}
return;
}
if (CpInazumaMsgPack.\uE005 == CpCustomDataPackMode.Map || CpInazumaMsgPack.\uE005 == CpCustomDataPackMode.Older)
{
CpInazumaMsgPack.\uE00B(\uE04A.\uE001.Count, CpInazumaMsgPack.\uE006(\uE04A.\uE001.Count), \uE04B);
for (int j = 0; j < \uE04A.\uE001.Count; j++)
{
\uE016 uE2 = \uE04A.\uE001[j];
CpInazumaMsgPack.\uE018(uE2.\uE001, \uE04B);
CpInazumaMsgPack.Pack(uE2.\uE002.GetValue(\uE049), \uE04B);
}
}
}
private static int \uE005(Stream \uE027, \uE015 \uE028, sbyte \uE029)
{
if (\uE028 == global::\uE015.\uE004)
{
return((int)\uE029);
}
if (\uE028 == global::\uE015.\uE002)
{
return((int)\uE029);
}
if (\uE028 == global::\uE015.\uE003)
{
return((int)\uE029);
}
if (!CpInazumaMsgPack.\uE00F(\uE028))
{
if (!CpInazumaMsgPack.\uE010(\uE028))
{
if (!CpInazumaMsgPack.\uE011(\uE028))
{
if (!CpInazumaMsgPack.\uE012(\uE028))
{
return(0);
}
}
}
}
return((int)CpInazumaMsgPack.\uE001(\uE027, CpInazumaMsgPack.\uE004(\uE028, \uE029)));
}
private static object \uE01D(Stream \uE053, \uE015 \uE054, sbyte \uE055, Type \uE056)
{
Type type = typeof(object);
Type type2 = typeof(object);
if (\uE056.IsGenericType)
{
Type[] genericArguments = \uE056.GetGenericArguments();
if (genericArguments.Length >= 1)
{
type = genericArguments[0];
}
if (genericArguments.Length >= 2)
{
type2 = genericArguments[1];
}
}
int num = CpInazumaMsgPack.\uE005(\uE053, \uE054, \uE055);
IDictionary dictionary = Activator.CreateInstance(typeof(Dictionary <, >).MakeGenericType(new Type[]
{
type,
type2
})) as IDictionary;
for (int i = 0; i < num; i++)
{
object key = CpInazumaMsgPack.Unpack(\uE053, type);
object value = CpInazumaMsgPack.Unpack(\uE053, type2);
dictionary.Add(key, value);
}
return(dictionary);
}
public static void Pack(object data, string file_path)
{
FileStream fileStream = new FileStream(file_path, FileMode.Create);
CpInazumaMsgPack.Pack(data, fileStream);
fileStream.Close();
}
public static string Dump(Stream stream)
{
if (stream != null && stream.CanRead)
{
if (stream.CanSeek)
{
StringBuilder stringBuilder = new StringBuilder(CpInazumaMsgPack.\uE003);
int num = 0;
stringBuilder.Append(global::\uE019.\uE000(11514));
long position = stream.Position;
while (stream.Position < stream.Length)
{
long position2 = stream.Position;
sbyte uE = 0;
\uE015 uE2 = CpInazumaMsgPack.\uE00A(stream, out uE);
string arg = CpInazumaMsgPack.\uE023(stream, uE2, uE);
num++;
stringBuilder.AppendFormat(global::\uE019.\uE000(11475), global::\uE019.\uE000(11297), uE2);
stringBuilder.AppendFormat(global::\uE019.\uE000(11475), global::\uE019.\uE000(11320), arg);
stringBuilder.AppendFormat(global::\uE019.\uE000(11312), global::\uE019.\uE000(11294), position2);
stringBuilder.AppendFormat(global::\uE019.\uE000(11312), global::\uE019.\uE000(11285), stream.Position - position2);
stringBuilder.Append(global::\uE019.\uE000(11372));
}
stringBuilder.AppendFormat(global::\uE019.\uE000(11333), global::\uE019.\uE000(11347), stream.Length);
stringBuilder.AppendFormat(global::\uE019.\uE000(12197), global::\uE019.\uE000(12214), num);
stringBuilder.AppendFormat(global::\uE019.\uE000(12169), global::\uE019.\uE000(12183), (double)stream.Length / (double)num);
stringBuilder.Append(global::\uE019.\uE000(12259));
stream.Seek(position, SeekOrigin.Begin);
return(stringBuilder.ToString());
}
}
return(string.Empty);
}
private static byte[] \uE01F(Stream \uE05A, \uE015 \uE05B, sbyte \uE05C)
{
int num = CpInazumaMsgPack.\uE005(\uE05A, \uE05B, \uE05C);
byte[] array = new byte[num];
\uE05A.Read(array, 0, num);
return(array);
}
private static string \uE01E(Stream \uE057, \uE015 \uE058, sbyte \uE059)
{
int num = CpInazumaMsgPack.\uE005(\uE057, \uE058, \uE059);
byte[] array = new byte[num];
\uE057.Read(array, 0, num);
return(CpInazumaMsgPack.\uE000.GetString(array));
}
private static long \uE001(Stream \uE021, int \uE022)
{
\uE022 = ((\uE022 > CpInazumaMsgPack.\uE001) ? CpInazumaMsgPack.\uE001 : \uE022);
byte[] array = new byte[\uE022];
\uE021.Read(array, 0, \uE022);
Array.Clear(CpInazumaMsgPack.\uE008, 0, CpInazumaMsgPack.\uE008.Length);
CpInazumaMsgPack.\uE000(array).CopyTo(CpInazumaMsgPack.\uE008, 0);
return(BitConverter.ToInt64(CpInazumaMsgPack.\uE008, 0));
}
public static string Dump(byte[] buffer)
{
if (buffer == null)
{
return(string.Empty);
}
MemoryStream memoryStream = new MemoryStream(buffer);
string result = CpInazumaMsgPack.Dump(memoryStream);
memoryStream.Close();
return(result);
}
public static object Unpack(byte[] buffer, Type type)
{
if (buffer == null)
{
return(null);
}
MemoryStream memoryStream = new MemoryStream(buffer);
object result = CpInazumaMsgPack.Unpack(memoryStream, type);
memoryStream.Close();
return(result);
}
public static T Unpack <T>(string file_path)
{
if (!File.Exists(file_path))
{
return(default(T));
}
FileStream fileStream = new FileStream(file_path, FileMode.Open);
T result = CpInazumaMsgPack.Unpack <T>(fileStream);
fileStream.Close();
return(result);
}
public static string Dump(string file_path)
{
if (!string.IsNullOrEmpty(file_path))
{
if (File.Exists(file_path))
{
FileStream fileStream = new FileStream(file_path, FileMode.Open);
string result = CpInazumaMsgPack.Dump(fileStream);
fileStream.Close();
return(result);
}
}
return(string.Empty);
}
private static object \uE020(Stream \uE05D, ref \uE017 \uE05E)
{
sbyte b = 0;
\uE015 uE = CpInazumaMsgPack.\uE00A(\uE05D, out b);
object obj = Activator.CreateInstance(\uE05E.\uE000);
if (CpInazumaMsgPack.\uE010(uE))
{
int num = CpInazumaMsgPack.\uE005(\uE05D, uE, b);
for (int i = 0; i < num; i++)
{
CpInazumaMsgPack.\uE001 uE2 = new CpInazumaMsgPack.\uE001();
uE = CpInazumaMsgPack.\uE00A(\uE05D, out b);
uE2.\uE000 = CpInazumaMsgPack.\uE01E(\uE05D, uE, b);
\uE016 uE3 = \uE05E.\uE001.Find(new Predicate <\uE016>(uE2.\uE000));
if (uE3 == null)
{
CpInazumaMsgPack.Unpack(\uE05D, typeof(object));
}
else
{
TypeCode typeCode = Type.GetTypeCode(uE3.\uE002.FieldType);
object value = CpInazumaMsgPack.\uE014(CpInazumaMsgPack.Unpack(\uE05D, uE3.\uE002.FieldType), typeCode);
uE3.\uE002.SetValue(obj, value);
}
}
return(obj);
}
if (CpInazumaMsgPack.\uE00F(uE))
{
\uE05D.Seek((long)CpInazumaMsgPack.\uE004(uE, b), SeekOrigin.Current);
return(CpInazumaMsgPack.\uE020(\uE05D, ref \uE05E));
}
\uE05D.Seek(-1L, SeekOrigin.Current);
if (uE == global::\uE015.\uE00A)
{
return(null);
}
for (int j = 0; j < \uE05E.\uE001.Count; j++)
{
FieldInfo uE4 = \uE05E.\uE001[j].\uE002;
object obj2 = CpInazumaMsgPack.Unpack(\uE05D, uE4.FieldType);
if (obj2 != null)
{
uE4.SetValue(obj, Convert.ChangeType(obj2, uE4.FieldType));
}
}
return(obj);
}
private static void \uE019(byte[] \uE047, Stream \uE048)
{
int num = \uE047.Length;
if (CpInazumaMsgPack.\uE005 == CpCustomDataPackMode.Older)
{
\uE048.WriteByte(219);
\uE048.Write(CpInazumaMsgPack.\uE000(BitConverter.GetBytes(num)), 0, 4);
}
else
{
CpInazumaMsgPack.\uE00B(num, CpInazumaMsgPack.\uE009(num), \uE048);
}
\uE048.Write(\uE047, 0, \uE047.Length);
}
public static object Unpack(Stream stream, Type type)
{
if (stream != null && stream.CanRead)
{
if (stream.CanSeek)
{
\uE017 uE = default(\uE017);
if (CpInazumaMsgPack.\uE022(type, ref uE))
{
return(CpInazumaMsgPack.\uE020(stream, ref uE));
}
sbyte b = 0;
\uE015 uE2 = CpInazumaMsgPack.\uE00A(stream, out b);
if (uE2 == global::\uE015.\uE00B)
{
stream.Seek(-1L, SeekOrigin.Current);
return(null);
}
if (uE2 == global::\uE015.\uE00A)
{
return(null);
}
if (CpInazumaMsgPack.\uE00E(uE2))
{
return(CpInazumaMsgPack.\uE01B(stream, uE2, b));
}
if (CpInazumaMsgPack.\uE00F(uE2))
{
return(CpInazumaMsgPack.\uE01C(stream, uE2, b, type));
}
if (CpInazumaMsgPack.\uE010(uE2))
{
return(CpInazumaMsgPack.\uE01D(stream, uE2, b, type));
}
if (CpInazumaMsgPack.\uE011(uE2))
{
return(CpInazumaMsgPack.\uE01E(stream, uE2, b));
}
if (CpInazumaMsgPack.\uE012(uE2))
{
return(CpInazumaMsgPack.\uE01F(stream, uE2, b));
}
stream.Seek(-1L, SeekOrigin.Current);
return(null);
}
}
throw new IOException(global::\uE019.\uE000(11502));
}
private static void \uE018(string \uE045, Stream \uE046)
{
byte[] bytes = CpInazumaMsgPack.\uE000.GetBytes(\uE045);
int num = bytes.Length;
if (CpInazumaMsgPack.\uE005 == CpCustomDataPackMode.Older)
{
\uE046.WriteByte(219);
\uE046.Write(CpInazumaMsgPack.\uE000(BitConverter.GetBytes(num)), 0, 4);
}
else
{
CpInazumaMsgPack.\uE00B(num, CpInazumaMsgPack.\uE008(num), \uE046);
}
\uE046.Write(bytes, 0, bytes.Length);
}
public static void Pack(object data, Stream stream)
{
if (stream != null)
{
if (stream.CanWrite)
{
if (data == null)
{
CpInazumaMsgPack.\uE00B(null, global::\uE015.\uE00A, stream);
return;
}
if (data.GetType().IsPrimitive)
{
CpInazumaMsgPack.\uE015(data, stream);
return;
}
if (data is string)
{
CpInazumaMsgPack.\uE018((string)data, stream);
return;
}
if (data is byte[])
{
CpInazumaMsgPack.\uE019((byte[])data, stream);
return;
}
if (data is IList)
{
CpInazumaMsgPack.\uE016((IList)data, stream);
return;
}
if (data is IDictionary)
{
CpInazumaMsgPack.\uE017((IDictionary)data, stream);
return;
}
\uE017 uE = default(\uE017);
if (CpInazumaMsgPack.\uE022(data.GetType(), ref uE))
{
CpInazumaMsgPack.\uE01A(data, ref uE, stream);
}
return;
}
}
throw new IOException(global::\uE019.\uE000(11502));
}
private static void \uE016(IList \uE041, Stream \uE042)
{
int count = \uE041.Count;
if (CpInazumaMsgPack.\uE005 == CpCustomDataPackMode.Older)
{
\uE042.WriteByte(221);
\uE042.Write(CpInazumaMsgPack.\uE000(BitConverter.GetBytes(count)), 0, 4);
}
else
{
CpInazumaMsgPack.\uE00B(\uE041.Count, CpInazumaMsgPack.\uE007(count), \uE042);
}
for (int i = 0; i < count; i++)
{
CpInazumaMsgPack.Pack(\uE041[i], \uE042);
}
}
private static object \uE01C(Stream \uE04F, \uE015 \uE050, sbyte \uE051, Type \uE052)
{
int num = CpInazumaMsgPack.\uE005(\uE04F, \uE050, \uE051);
Type type = null;
IList list = CpInazumaMsgPack.\uE013(\uE052, num, out type);
for (int i = 0; i < num; i++)
{
object value = CpInazumaMsgPack.Unpack(\uE04F, type);
try
{
list[i] = Convert.ChangeType(value, type);
}
catch (InvalidCastException)
{
list[i] = value;
}
}
return(list);
}
private static void \uE017(IDictionary \uE043, Stream \uE044)
{
int count = \uE043.Count;
if (CpInazumaMsgPack.\uE005 == CpCustomDataPackMode.Older)
{
\uE044.WriteByte(223);
\uE044.Write(CpInazumaMsgPack.\uE000(BitConverter.GetBytes(count)), 0, 4);
}
else
{
CpInazumaMsgPack.\uE00B(count, CpInazumaMsgPack.\uE006(count), \uE044);
}
foreach (object obj in \uE043)
{
DictionaryEntry dictionaryEntry = (DictionaryEntry)obj;
CpInazumaMsgPack.Pack(dictionaryEntry.Key, \uE044);
CpInazumaMsgPack.Pack(dictionaryEntry.Value, \uE044);
}
}
private static string \uE023(Stream \uE062, \uE015 \uE063, sbyte \uE064)
{
if (\uE063 == global::\uE015.\uE00B)
{
return(global::\uE019.\uE000(12244));
}
if (\uE063 == global::\uE015.\uE00A)
{
return(global::\uE019.\uE000(12078));
}
if (CpInazumaMsgPack.\uE00E(\uE063))
{
return(CpInazumaMsgPack.\uE01B(\uE062, \uE063, \uE064).ToString());
}
if (CpInazumaMsgPack.\uE00F(\uE063))
{
int num = CpInazumaMsgPack.\uE005(\uE062, \uE063, \uE064);
return(string.Format(global::\uE019.\uE000(12075), num));
}
if (CpInazumaMsgPack.\uE010(\uE063))
{
int num2 = CpInazumaMsgPack.\uE005(\uE062, \uE063, \uE064);
return(string.Format(global::\uE019.\uE000(12085), num2));
}
if (CpInazumaMsgPack.\uE011(\uE063))
{
string text = CpInazumaMsgPack.\uE01E(\uE062, \uE063, \uE064);
if (CpInazumaMsgPack.\uE00A)
{
text = text.Replace(global::\uE019.\uE000(12036), "").Replace(global::\uE019.\uE000(12038), "");
}
return(string.Format(global::\uE019.\uE000(12032), text.Substring(0, Math.Min(text.Length, CpInazumaMsgPack.\uE009))));
}
if (CpInazumaMsgPack.\uE012(\uE063))
{
return(string.Format(global::\uE019.\uE000(12062), CpInazumaMsgPack.\uE01F(\uE062, \uE063, \uE064).Length));
}
return(string.Empty);
}
public static T Unpack <T>(Stream stream)
{
Type typeFromHandle = typeof(T);
return((T)((object)Convert.ChangeType(CpInazumaMsgPack.Unpack(stream, typeFromHandle), typeFromHandle)));
}
private static bool \uE021 <\uE000>(ref \uE017 \uE05F)
{
return(CpInazumaMsgPack.\uE022(typeof(\uE000), ref \uE05F));
}
private static bool \uE022(Type \uE060, ref \uE017 \uE061)
{
if (CpInazumaMsgPack.\uE007.TryGetValue(\uE060, out \uE061))
{
return(true);
}
if (\uE060.IsPrimitive || typeof(IList).IsAssignableFrom(\uE060) || typeof(IDictionary).IsAssignableFrom(\uE060) || \uE060 == typeof(object) || typeof(string) == \uE060)
{
return(false);
}
BindingFlags bindingAttr = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
FieldInfo[] fields = \uE060.GetFields(bindingAttr);
List <\uE016> list = new List <\uE016>(fields.Length);
bool flag = false;
foreach (FieldInfo fieldInfo in fields)
{
if (!fieldInfo.IsDefined(typeof(NonSerializedAttribute), false))
{
\uE016 uE = new \uE016();
uE.\uE001 = fieldInfo.Name;
uE.\uE000 = int.MaxValue;
uE.\uE002 = fieldInfo;
object[] customAttributes = fieldInfo.GetCustomAttributes(typeof(CpSerializeFieldAttribute), false);
if (customAttributes.Length > 0 && customAttributes[0] is CpSerializeFieldAttribute)
{
flag = true;
CpSerializeFieldAttribute cpSerializeFieldAttribute = customAttributes[0] as CpSerializeFieldAttribute;
uE.\uE001 = (cpSerializeFieldAttribute.Name ?? fieldInfo.Name);
uE.\uE000 = cpSerializeFieldAttribute.Order;
}
list.Add(uE);
}
}
if (flag)
{
List <\uE016> list2 = list;
if (CpInazumaMsgPack.\uE00B == null)
{
CpInazumaMsgPack.\uE00B = new Comparison <\uE016>(CpInazumaMsgPack.\uE024);
}
list2.Sort(CpInazumaMsgPack.\uE00B);
}
else
{
List <\uE016> list3 = list;
if (CpInazumaMsgPack.\uE00C == null)
{
CpInazumaMsgPack.\uE00C = new Comparison <\uE016>(CpInazumaMsgPack.\uE025);
}
list3.Sort(CpInazumaMsgPack.\uE00C);
}
\uE017 uE2 = default(\uE017);
uE2.\uE000 = \uE060;
uE2.\uE001 = list;
CpInazumaMsgPack.\uE007[\uE060] = uE2;
\uE017 uE3 = default(\uE017);
for (int j = 0; j < list.Count; j++)
{
CpInazumaMsgPack.\uE022(list[j].\uE002.FieldType, ref uE3);
}
\uE061 = uE2;
return(true);
}
public static T Unpack <T>(byte[] buffer)
{
return((T)((object)Convert.ChangeType(CpInazumaMsgPack.Unpack(buffer, typeof(T)), typeof(T))));
}
private static float \uE002(Stream \uE023)
{
byte[] array = new byte[4];
\uE023.Read(array, 0, 4);
return(BitConverter.ToSingle(CpInazumaMsgPack.\uE000(array), 0));
}
private static double \uE003(Stream \uE024)
{
byte[] array = new byte[8];
\uE024.Read(array, 0, 8);
return(BitConverter.ToDouble(CpInazumaMsgPack.\uE000(array), 0));
}
private static void \uE015(object \uE03F, Stream \uE040)
{
TypeCode typeCode = Type.GetTypeCode(\uE03F.GetType());
if (CpInazumaMsgPack.\uE00D(typeCode) && Convert.ToInt64(\uE03F) < 0L && Convert.ToInt64(\uE03F) >= -32L)
{
CpInazumaMsgPack.\uE00B(\uE03F, global::\uE015.\uE001, \uE040);
return;
}
if (CpInazumaMsgPack.\uE00C(typeCode))
{
if (!CpInazumaMsgPack.\uE00D(typeCode))
{
if (Convert.ToUInt64(\uE03F) <= 127UL)
{
CpInazumaMsgPack.\uE00B(\uE03F, global::\uE015.\uE000, \uE040);
return;
}
}
}
switch (typeCode)
{
case TypeCode.Boolean:
CpInazumaMsgPack.\uE00B(null, ((bool)\uE03F) ? global::\uE015.\uE00D : global::\uE015.\uE00C, \uE040);
return;
case TypeCode.Char:
CpInazumaMsgPack.\uE00B(\uE03F, global::\uE015.\uE017, \uE040);
return;
case TypeCode.SByte:
CpInazumaMsgPack.\uE00B(\uE03F, global::\uE015.\uE01A, \uE040);
return;
case TypeCode.Byte:
CpInazumaMsgPack.\uE00B(\uE03F, global::\uE015.\uE016, \uE040);
return;
case TypeCode.Int16:
CpInazumaMsgPack.\uE00B(\uE03F, global::\uE015.\uE01B, \uE040);
return;
case TypeCode.UInt16:
CpInazumaMsgPack.\uE00B(\uE03F, global::\uE015.\uE017, \uE040);
return;
case TypeCode.Int32:
CpInazumaMsgPack.\uE00B(\uE03F, global::\uE015.\uE01C, \uE040);
return;
case TypeCode.UInt32:
CpInazumaMsgPack.\uE00B(\uE03F, global::\uE015.\uE018, \uE040);
return;
case TypeCode.Int64:
CpInazumaMsgPack.\uE00B(\uE03F, global::\uE015.\uE01D, \uE040);
return;
case TypeCode.UInt64:
CpInazumaMsgPack.\uE00B(\uE03F, global::\uE015.\uE019, \uE040);
return;
case TypeCode.Single:
CpInazumaMsgPack.\uE00B(\uE03F, global::\uE015.\uE014, \uE040);
return;
case TypeCode.Double:
CpInazumaMsgPack.\uE00B(\uE03F, global::\uE015.\uE015, \uE040);
return;
default:
return;
}
}
private static object \uE01B(Stream \uE04C, \uE015 \uE04D, sbyte \uE04E)
{
if (\uE04D != global::\uE015.\uE000)
{
switch (\uE04D)
{
case global::\uE015.\uE00C:
return(false);
case global::\uE015.\uE00D:
return(true);
case global::\uE015.\uE00E:
case global::\uE015.\uE00F:
case global::\uE015.\uE010:
case global::\uE015.\uE011:
case global::\uE015.\uE012:
case global::\uE015.\uE013:
break;
case global::\uE015.\uE014:
return(CpInazumaMsgPack.\uE002(\uE04C));
case global::\uE015.\uE015:
return(CpInazumaMsgPack.\uE003(\uE04C));
case global::\uE015.\uE016:
return((byte)\uE04C.ReadByte());
case global::\uE015.\uE017:
return((ushort)CpInazumaMsgPack.\uE001(\uE04C, 2));
case global::\uE015.\uE018:
return((uint)CpInazumaMsgPack.\uE001(\uE04C, 4));
case global::\uE015.\uE019:
return((ulong)CpInazumaMsgPack.\uE001(\uE04C, 8));
case global::\uE015.\uE01A:
return((sbyte)\uE04C.ReadByte());
case global::\uE015.\uE01B:
return((short)CpInazumaMsgPack.\uE001(\uE04C, 2));
case global::\uE015.\uE01C:
return((int)CpInazumaMsgPack.\uE001(\uE04C, 4));
case global::\uE015.\uE01D:
return(CpInazumaMsgPack.\uE001(\uE04C, 8));
default:
if (\uE04D == global::\uE015.\uE001)
{
return(\uE04E);
}
break;
}
return(null);
}
return((byte)\uE04E);
}
private static void \uE00B(object \uE030, \uE015 \uE031, Stream \uE032)
{
if (\uE031 <= global::\uE015.\uE002)
{
if (\uE031 == global::\uE015.\uE000)
{
ulong num = Convert.ToUInt64(\uE030);
\uE032.WriteByte(Convert.ToByte(num & 255UL));
return;
}
if (\uE031 != global::\uE015.\uE002)
{
return;
}
}
else if (\uE031 != global::\uE015.\uE003)
{
switch (\uE031)
{
case global::\uE015.\uE004:
\uE032.WriteByte((byte)(\uE031 | (\uE015)(Convert.ToByte(\uE030) & 31)));
return;
case (\uE015)161:
case (\uE015)162:
case (\uE015)163:
case (\uE015)164:
case (\uE015)165:
case (\uE015)166:
case (\uE015)167:
case (\uE015)168:
case (\uE015)169:
case (\uE015)170:
case (\uE015)171:
case (\uE015)172:
case (\uE015)173:
case (\uE015)174:
case (\uE015)175:
case (\uE015)176:
case (\uE015)177:
case (\uE015)178:
case (\uE015)179:
case (\uE015)180:
case (\uE015)181:
case (\uE015)182:
case (\uE015)183:
case (\uE015)184:
case (\uE015)185:
case (\uE015)186:
case (\uE015)187:
case (\uE015)188:
case (\uE015)189:
case (\uE015)190:
case (\uE015)191:
case global::\uE015.\uE00B:
break;
case global::\uE015.\uE00A:
case global::\uE015.\uE00C:
case global::\uE015.\uE00D:
\uE032.WriteByte((byte)\uE031);
return;
case global::\uE015.\uE00E:
case global::\uE015.\uE011:
case global::\uE015.\uE016:
case global::\uE015.\uE005:
case global::\uE015.\uE006:
case global::\uE015.\uE007:
case global::\uE015.\uE008:
case global::\uE015.\uE009:
case global::\uE015.\uE01E:
\uE032.WriteByte((byte)\uE031);
\uE032.WriteByte(Convert.ToByte(\uE030));
return;
case global::\uE015.\uE00F:
case global::\uE015.\uE012:
case global::\uE015.\uE017:
case global::\uE015.\uE01F:
case global::\uE015.\uE021:
case global::\uE015.\uE023:
\uE032.WriteByte((byte)\uE031);
\uE032.Write(CpInazumaMsgPack.\uE000(BitConverter.GetBytes(Convert.ToUInt16(\uE030))), 0, 2);
return;
case global::\uE015.\uE010:
case global::\uE015.\uE013:
case global::\uE015.\uE018:
case global::\uE015.\uE020:
case global::\uE015.\uE022:
case global::\uE015.\uE024:
\uE032.WriteByte((byte)\uE031);
\uE032.Write(CpInazumaMsgPack.\uE000(BitConverter.GetBytes(Convert.ToUInt32(\uE030))), 0, 4);
return;
case global::\uE015.\uE014:
\uE032.WriteByte((byte)\uE031);
\uE032.Write(CpInazumaMsgPack.\uE000(BitConverter.GetBytes(Convert.ToSingle(\uE030))), 0, 4);
return;
case global::\uE015.\uE015:
\uE032.WriteByte((byte)\uE031);
\uE032.Write(CpInazumaMsgPack.\uE000(BitConverter.GetBytes(Convert.ToDouble(\uE030))), 0, 8);
return;
case global::\uE015.\uE019:
\uE032.WriteByte((byte)\uE031);
\uE032.Write(CpInazumaMsgPack.\uE000(BitConverter.GetBytes(Convert.ToUInt64(\uE030))), 0, 8);
return;
case global::\uE015.\uE01A:
\uE032.WriteByte((byte)\uE031);
\uE032.Write(CpInazumaMsgPack.\uE000(BitConverter.GetBytes((short)Convert.ToSByte(\uE030))), 0, 1);
return;
case global::\uE015.\uE01B:
\uE032.WriteByte((byte)\uE031);
\uE032.Write(CpInazumaMsgPack.\uE000(BitConverter.GetBytes(Convert.ToInt16(\uE030))), 0, 2);
return;
case global::\uE015.\uE01C:
\uE032.WriteByte((byte)\uE031);
\uE032.Write(CpInazumaMsgPack.\uE000(BitConverter.GetBytes(Convert.ToInt32(\uE030))), 0, 4);
return;
case global::\uE015.\uE01D:
\uE032.WriteByte((byte)\uE031);
\uE032.Write(CpInazumaMsgPack.\uE000(BitConverter.GetBytes(Convert.ToInt64(\uE030))), 0, 8);
break;
case global::\uE015.\uE001:
{
long num2 = Convert.ToInt64(\uE030);
\uE032.WriteByte(Convert.ToByte(num2 & 255L));
return;
}
default:
return;
}
return;
}
\uE032.WriteByte((byte)(\uE031 | (\uE015)(Convert.ToByte(\uE030) & 15)));
}
