mirror of
https://github.com/Alukym/VMProtect-Source.git
synced 2025-06-12 07:48:18 -05:00
Initial commit
This commit is contained in:
Alukym
@ -0,0 +1,172 @@
|
||||
using System;
|
||||
using System.Diagnostics;
|
||||
|
||||
namespace UnitTestProject.RefVm
|
||||
{
|
||||
// Token: 0x02000048 RID: 72
|
||||
internal static class ElementedTypeHelper // \u0008\u2005
|
||||
{
|
||||
// Token: 0x06000307 RID: 775 RVA: 0x000148D8 File Offset: 0x00012AD8
|
||||
public static Type TryGoToElementType(Type t) // \u0002
|
||||
{
|
||||
if (t.IsByRef || t.IsArray || t.IsPointer)
|
||||
{
|
||||
return TryGoToElementType(t.GetElementType());
|
||||
}
|
||||
return t;
|
||||
}
|
||||
|
||||
// Token: 0x06000308 RID: 776 RVA: 0x00014900 File Offset: 0x00012B00
|
||||
public static Type TryGoToPointerOrReferenceElementType(Type t) // \u0003
|
||||
{
|
||||
if (t.HasElementType && !t.IsArray)
|
||||
{
|
||||
t = t.GetElementType();
|
||||
}
|
||||
return t;
|
||||
}
|
||||
|
||||
// Token: 0x06000309 RID: 777 RVA: 0x00014920 File Offset: 0x00012B20
|
||||
public static MyCollection<ElementedTypeDescrItem> NestedElementTypes(Type type) // \u0002
|
||||
{
|
||||
var collection = new MyCollection<ElementedTypeDescrItem>();
|
||||
while (true)
|
||||
{
|
||||
Debug.Assert(type != null, "type != null");
|
||||
if(type == null) return collection;
|
||||
if (type.IsArray)
|
||||
{
|
||||
collection.PushBack(new ElementedTypeDescrItem
|
||||
{
|
||||
K = ElementedTypeDescrItem.Kind.Array1,
|
||||
ArrayRank = type.GetArrayRank()
|
||||
});
|
||||
}
|
||||
else if (type.IsByRef)
|
||||
{
|
||||
collection.PushBack(new ElementedTypeDescrItem
|
||||
{
|
||||
K = ElementedTypeDescrItem.Kind.ByRef2
|
||||
});
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!type.IsPointer)
|
||||
{
|
||||
break;
|
||||
}
|
||||
collection.PushBack(new ElementedTypeDescrItem
|
||||
{
|
||||
K = ElementedTypeDescrItem.Kind.Ponter0
|
||||
});
|
||||
}
|
||||
type = type.GetElementType();
|
||||
}
|
||||
return collection;
|
||||
}
|
||||
|
||||
// Token: 0x0600030A RID: 778 RVA: 0x000149B0 File Offset: 0x00012BB0
|
||||
public static MyCollection<ElementedTypeDescrItem> NestedElementTypes(string text) // \u0002
|
||||
{
|
||||
var collection = new MyCollection<ElementedTypeDescrItem>();
|
||||
while (true)
|
||||
{
|
||||
if (text.EndsWith(StringDecryptor.GetString(-1550346966) /* & */, StringComparison.Ordinal))
|
||||
{
|
||||
collection.PushBack(new ElementedTypeDescrItem
|
||||
{
|
||||
K = ElementedTypeDescrItem.Kind.ByRef2
|
||||
});
|
||||
text = text.Substring(0, text.Length - 1);
|
||||
}
|
||||
else if (text.EndsWith(StringDecryptor.GetString(-1550346958) /* * */, StringComparison.Ordinal))
|
||||
{
|
||||
collection.PushBack(new ElementedTypeDescrItem
|
||||
{
|
||||
K = ElementedTypeDescrItem.Kind.Ponter0
|
||||
});
|
||||
text = text.Substring(0, text.Length - 1);
|
||||
}
|
||||
else if (text.EndsWith(StringDecryptor.GetString(-1550346950) /* [] */, StringComparison.Ordinal))
|
||||
{
|
||||
collection.PushBack(new ElementedTypeDescrItem
|
||||
{
|
||||
K = ElementedTypeDescrItem.Kind.Array1,
|
||||
ArrayRank = 1
|
||||
});
|
||||
text = text.Substring(0, text.Length - 2);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!text.EndsWith(StringDecryptor.GetString(-1550346811) /* ,] */, StringComparison.Ordinal))
|
||||
{
|
||||
return collection;
|
||||
}
|
||||
var rank = 1;
|
||||
var remainLen = -1;
|
||||
for (var i = text.Length - 2; i >= 0; i--)
|
||||
{
|
||||
var c = text[i];
|
||||
if (c != ',')
|
||||
{
|
||||
if (c != '[')
|
||||
{
|
||||
throw new InvalidOperationException(StringDecryptor.GetString(-1550346804) /* VM-3012 */);
|
||||
}
|
||||
remainLen = i;
|
||||
i = -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
rank++;
|
||||
}
|
||||
}
|
||||
if (remainLen < 0)
|
||||
{
|
||||
throw new InvalidOperationException(StringDecryptor.GetString(-1550346790) /* VM-3014 */);
|
||||
}
|
||||
text = text.Substring(0, remainLen);
|
||||
collection.PushBack(new ElementedTypeDescrItem
|
||||
{
|
||||
K = ElementedTypeDescrItem.Kind.Array1,
|
||||
ArrayRank = rank
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x0600030B RID: 779 RVA: 0x00014B30 File Offset: 0x00012D30
|
||||
public static Type PopType(Type type, MyCollection<ElementedTypeDescrItem> descr) // \u0002
|
||||
{
|
||||
while (descr.Count > 0)
|
||||
{
|
||||
var p = descr.PopBack();
|
||||
switch (p.K)
|
||||
{
|
||||
case ElementedTypeDescrItem.Kind.Ponter0:
|
||||
type = type.MakePointerType();
|
||||
break;
|
||||
case ElementedTypeDescrItem.Kind.Array1:
|
||||
type = (p.ArrayRank == 1) ? type.MakeArrayType() : type.MakeArrayType(p.ArrayRank);
|
||||
break;
|
||||
case ElementedTypeDescrItem.Kind.ByRef2:
|
||||
type = type.MakeByRefType();
|
||||
break;
|
||||
}
|
||||
}
|
||||
return type;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x02000054 RID: 84
|
||||
internal struct ElementedTypeDescrItem // \u000E\u2005
|
||||
{
|
||||
internal enum Kind { Ponter0, Array1, ByRef2 }
|
||||
|
||||
// Token: 0x04000183 RID: 387
|
||||
public Kind K; // \u0002
|
||||
|
||||
// Token: 0x04000184 RID: 388
|
||||
public int ArrayRank; // \u0003
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,569 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace UnitTestProject.RefVm
|
||||
{
|
||||
// Token: 0x02000024 RID: 36
|
||||
internal sealed class MyBuffer : IDisposable // \u0005\u2007
|
||||
{
|
||||
// Token: 0x060000F2 RID: 242 RVA: 0x000051C8 File begin: 0x000033C8
|
||||
public MyBuffer() : this(0)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x060000F3 RID: 243 RVA: 0x000051D4 File begin: 0x000033D4
|
||||
public MyBuffer(int sz)
|
||||
{
|
||||
if (sz < 0)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
_data = new byte[sz];
|
||||
_size = sz;
|
||||
_internal = true;
|
||||
_writable = true;
|
||||
_begin = 0;
|
||||
_valid = true;
|
||||
}
|
||||
|
||||
// Token: 0x060000F4 RID: 244 RVA: 0x00005220 File begin: 0x00003420
|
||||
public MyBuffer(byte[] src) : this(src, true)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x060000F5 RID: 245 RVA: 0x0000522C File begin: 0x0000342C
|
||||
public MyBuffer(byte[] src, bool writable)
|
||||
{
|
||||
if (src == null)
|
||||
{
|
||||
throw new ArgumentNullException();
|
||||
}
|
||||
_data = src;
|
||||
_end = (_size = src.Length);
|
||||
_writable = writable;
|
||||
_begin = 0;
|
||||
_valid = true;
|
||||
}
|
||||
|
||||
// Token: 0x060000F6 RID: 246 RVA: 0x00005278 File begin: 0x00003478
|
||||
public MyBuffer(byte[] src, int begin, int count) : this(src, begin, count, true)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x060000F7 RID: 247 RVA: 0x00005284 File begin: 0x00003484
|
||||
public MyBuffer(byte[] src, int begin, int count, bool writable)
|
||||
{
|
||||
if (src == null)
|
||||
{
|
||||
throw new ArgumentNullException();
|
||||
}
|
||||
if (begin < 0)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
if (count < 0)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
if (src.Length - begin < count)
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
_data = src;
|
||||
_cursor = begin;
|
||||
_begin = begin;
|
||||
_end = (_size = begin + count);
|
||||
_writable = writable;
|
||||
_internal = false;
|
||||
_valid = true;
|
||||
}
|
||||
|
||||
// Token: 0x060000F8 RID: 248 RVA: 0x00005304 File begin: 0x00003504
|
||||
public bool IsValid() // \u0002
|
||||
{
|
||||
return _valid;
|
||||
}
|
||||
|
||||
// Token: 0x060000F9 RID: 249 RVA: 0x0000530C File begin: 0x0000350C
|
||||
public bool IsValid2() // \u0003
|
||||
{
|
||||
return _valid;
|
||||
}
|
||||
|
||||
// Token: 0x060000FA RID: 250 RVA: 0x00005314 File begin: 0x00003514
|
||||
public bool IsWritable() // \u0005
|
||||
{
|
||||
return _writable;
|
||||
}
|
||||
|
||||
// Token: 0x060000FB RID: 251 RVA: 0x0000531C File begin: 0x0000351C
|
||||
public void DoDispose() // \u0002
|
||||
{
|
||||
Dispose(true);
|
||||
// ReSharper disable once GCSuppressFinalizeForTypeWithoutDestructor
|
||||
GC.SuppressFinalize(this);
|
||||
}
|
||||
|
||||
// Token: 0x060000FC RID: 252 RVA: 0x0000532C File begin: 0x0000352C
|
||||
public void Dispose()
|
||||
{
|
||||
Dispose(false);
|
||||
}
|
||||
|
||||
// Token: 0x060000FD RID: 253 RVA: 0x00005334 File begin: 0x00003534
|
||||
private void Dispose(bool disposing) // \u0002
|
||||
{
|
||||
if (!_disposed)
|
||||
{
|
||||
if (disposing)
|
||||
{
|
||||
_valid = false;
|
||||
_writable = false;
|
||||
_internal = false;
|
||||
}
|
||||
_disposed = true;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060000FE RID: 254 RVA: 0x00005360 File begin: 0x00003560
|
||||
private bool Expand(int newSize) // \u0002
|
||||
{
|
||||
if (newSize < 0)
|
||||
{
|
||||
throw new IOException();
|
||||
}
|
||||
if (newSize > _size)
|
||||
{
|
||||
if (newSize < 256)
|
||||
{
|
||||
newSize = 256;
|
||||
}
|
||||
if (newSize < _size * 2)
|
||||
{
|
||||
newSize = _size * 2;
|
||||
}
|
||||
ExpandExact(newSize);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Token: 0x060000FF RID: 255 RVA: 0x000053B0 File begin: 0x000035B0
|
||||
public void DoNothing() // \u0003
|
||||
{}
|
||||
|
||||
// Token: 0x06000100 RID: 256 RVA: 0x000053B4 File begin: 0x000035B4
|
||||
internal byte[] Data() // \u0002
|
||||
{
|
||||
return _data;
|
||||
}
|
||||
|
||||
// Token: 0x06000101 RID: 257 RVA: 0x000053BC File begin: 0x000035BC
|
||||
internal void GetRanges(out int begin, out int end) // \u0002
|
||||
{
|
||||
if (!_valid)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
begin = _begin;
|
||||
end = _end;
|
||||
}
|
||||
|
||||
// Token: 0x06000102 RID: 258 RVA: 0x000053DC File begin: 0x000035DC
|
||||
internal int GetCursor() // \u0002
|
||||
{
|
||||
if (!_valid)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
return _cursor;
|
||||
}
|
||||
|
||||
// Token: 0x06000103 RID: 259 RVA: 0x000053F4 File begin: 0x000035F4
|
||||
public int SkipBytes(int cnt) // \u0002
|
||||
{
|
||||
if (!_valid)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
var num = _end - _cursor;
|
||||
if (num > cnt)
|
||||
{
|
||||
num = cnt;
|
||||
}
|
||||
if (num < 0)
|
||||
{
|
||||
num = 0;
|
||||
}
|
||||
_cursor += num;
|
||||
return num;
|
||||
}
|
||||
|
||||
// Token: 0x06000104 RID: 260 RVA: 0x00005438 File begin: 0x00003638
|
||||
public int Capacity() // \u0003
|
||||
{
|
||||
if (!_valid)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
return _size - _begin;
|
||||
}
|
||||
|
||||
// Token: 0x06000105 RID: 261 RVA: 0x00005458 File begin: 0x00003658
|
||||
public void ExpandExact(int newSize) // \u0002
|
||||
{
|
||||
if (!_valid)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
if (newSize != _size)
|
||||
{
|
||||
if (!_internal)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
if (newSize < _end)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
if (newSize > 0)
|
||||
{
|
||||
var dst = new byte[newSize];
|
||||
if (_end > 0)
|
||||
{
|
||||
Buffer.BlockCopy(_data, 0, dst, 0, _end);
|
||||
}
|
||||
_data = dst;
|
||||
}
|
||||
else
|
||||
{
|
||||
_data = null;
|
||||
}
|
||||
_size = newSize;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000106 RID: 262 RVA: 0x000054D8 File begin: 0x000036D8
|
||||
public long UsedSize() // \u0002
|
||||
{
|
||||
if (!_valid)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
return _end - _begin;
|
||||
}
|
||||
|
||||
// Token: 0x06000107 RID: 263 RVA: 0x000054F8 File begin: 0x000036F8
|
||||
public long GetPos() // \u0003
|
||||
{
|
||||
if (!_valid)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
return _cursor - _begin;
|
||||
}
|
||||
|
||||
// Token: 0x06000108 RID: 264 RVA: 0x00005518 File begin: 0x00003718
|
||||
public void SetPos(long newPos) // \u0002
|
||||
{
|
||||
if (!_valid)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
if (newPos < 0L)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
if (newPos > 2147483647L)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
_cursor = _begin + (int)newPos;
|
||||
}
|
||||
|
||||
// Token: 0x06000109 RID: 265 RVA: 0x00005554 File begin: 0x00003754
|
||||
public int Read([In] [Out] byte[] dest, int offset, int cnt) // \u0002
|
||||
{
|
||||
if (!_valid)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
if (dest == null)
|
||||
{
|
||||
throw new ArgumentNullException();
|
||||
}
|
||||
if (offset < 0)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
if (cnt < 0)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
if (dest.Length - offset < cnt)
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
var num = _end - _cursor;
|
||||
if (num > cnt)
|
||||
{
|
||||
num = cnt;
|
||||
}
|
||||
if (num <= 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
if (num <= 8)
|
||||
{
|
||||
var num2 = num;
|
||||
while (--num2 >= 0)
|
||||
{
|
||||
dest[offset + num2] = _data[_cursor + num2];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Buffer.BlockCopy(_data, _cursor, dest, offset, num);
|
||||
}
|
||||
_cursor += num;
|
||||
return num;
|
||||
}
|
||||
|
||||
// Token: 0x0600010A RID: 266 RVA: 0x00005600 File begin: 0x00003800
|
||||
public int ReadByte() // \u0005
|
||||
{
|
||||
if (!_valid)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
if (_cursor >= _end)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
var num = _cursor;
|
||||
_cursor = num + 1;
|
||||
return _data[num];
|
||||
}
|
||||
|
||||
// Token: 0x0600010B RID: 267 RVA: 0x00005644 File begin: 0x00003844
|
||||
public long Seek(long distance, SeekOrigin org) // \u0002
|
||||
{
|
||||
if (!_valid)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
if (distance > 2147483647L)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
switch (org)
|
||||
{
|
||||
case SeekOrigin.Begin:
|
||||
if (distance < 0L)
|
||||
{
|
||||
throw new IOException();
|
||||
}
|
||||
_cursor = _begin + (int)distance;
|
||||
break;
|
||||
case SeekOrigin.Current:
|
||||
if (distance + _cursor < _begin)
|
||||
{
|
||||
throw new IOException();
|
||||
}
|
||||
_cursor += (int)distance;
|
||||
break;
|
||||
case SeekOrigin.End:
|
||||
if (_end + distance < _begin)
|
||||
{
|
||||
throw new IOException();
|
||||
}
|
||||
_cursor = _end + (int)distance;
|
||||
break;
|
||||
default:
|
||||
throw new ArgumentException();
|
||||
}
|
||||
return _cursor;
|
||||
}
|
||||
|
||||
// Token: 0x0600010C RID: 268 RVA: 0x00005700 File begin: 0x00003900
|
||||
public void LazyShrink(long newCount) // \u0003
|
||||
{
|
||||
if (!_writable)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
if (newCount > 2147483647L)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
if (newCount < 0L || newCount > 2147483647 - _begin)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
var num = _begin + (int)newCount;
|
||||
if (!Expand(num) && num > _end)
|
||||
{
|
||||
Array.Clear(_data, _end, num - _end);
|
||||
}
|
||||
_end = num;
|
||||
if (_cursor > num)
|
||||
{
|
||||
_cursor = num;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x0600010D RID: 269 RVA: 0x00005794 File begin: 0x00003994
|
||||
public byte[] ToArray() // \u0003
|
||||
{
|
||||
var array = new byte[_end - _begin];
|
||||
Buffer.BlockCopy(_data, _begin, array, 0, _end - _begin);
|
||||
return array;
|
||||
}
|
||||
|
||||
// Token: 0x0600010E RID: 270 RVA: 0x000057D8 File begin: 0x000039D8
|
||||
public void Write(byte[] src, int offset, int cnt) // \u0002
|
||||
{
|
||||
if (!_valid)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
if (!_writable)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
if (src == null)
|
||||
{
|
||||
throw new ArgumentNullException();
|
||||
}
|
||||
if (offset < 0)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
if (cnt < 0)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
if (src.Length - offset < cnt)
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
var num = _cursor + cnt;
|
||||
if (num < 0)
|
||||
{
|
||||
throw new IOException();
|
||||
}
|
||||
if (num > _end)
|
||||
{
|
||||
var flag = _cursor > _end;
|
||||
if (num > _size && Expand(num))
|
||||
{
|
||||
flag = false;
|
||||
}
|
||||
if (flag)
|
||||
{
|
||||
Array.Clear(_data, _end, num - _end);
|
||||
}
|
||||
_end = num;
|
||||
}
|
||||
if (cnt <= 8)
|
||||
{
|
||||
while (--cnt >= 0)
|
||||
{
|
||||
_data[_cursor + cnt] = src[offset + cnt];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Buffer.BlockCopy(src, offset, _data, _cursor, cnt);
|
||||
}
|
||||
_cursor = num;
|
||||
}
|
||||
|
||||
// Token: 0x0600010F RID: 271 RVA: 0x000058D0 File begin: 0x00003AD0
|
||||
public void AppendByte(byte b) // \u0002
|
||||
{
|
||||
if (!_valid)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
if (!_writable)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
if (_cursor >= _end)
|
||||
{
|
||||
var num = _cursor + 1;
|
||||
var flag = _cursor > _end;
|
||||
if (num >= _size && Expand(num))
|
||||
{
|
||||
flag = false;
|
||||
}
|
||||
if (flag)
|
||||
{
|
||||
Array.Clear(_data, _end, _cursor - _end);
|
||||
}
|
||||
_end = num;
|
||||
}
|
||||
_data[_cursor] = b;
|
||||
_cursor++;
|
||||
}
|
||||
|
||||
// Token: 0x06000110 RID: 272 RVA: 0x00005974 File begin: 0x00003B74
|
||||
public void WriteTo(Stream s) // \u0002
|
||||
{
|
||||
if (!_valid)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
if (s == null)
|
||||
{
|
||||
throw new ArgumentNullException();
|
||||
}
|
||||
s.Write(_data, _begin, _end - _begin);
|
||||
}
|
||||
|
||||
// Token: 0x06000111 RID: 273 RVA: 0x000059AC File begin: 0x00003BAC
|
||||
internal int ReadInt32() // \u0008
|
||||
{
|
||||
if (!_valid)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
var num = _cursor += 4;
|
||||
if (num > _end)
|
||||
{
|
||||
_cursor = _end;
|
||||
throw new Exception();
|
||||
}
|
||||
return _data[num - 2] | _data[num - 3] << 24 | _data[num - 1] << 8 | _data[num - 4] << 16;
|
||||
}
|
||||
|
||||
// Token: 0x04000034 RID: 52
|
||||
private byte[] _data; // \u0002
|
||||
|
||||
// Token: 0x04000035 RID: 53
|
||||
private readonly int _begin; // \u0003
|
||||
|
||||
// Token: 0x04000036 RID: 54
|
||||
private int _cursor; // \u0005
|
||||
|
||||
// Token: 0x04000037 RID: 55
|
||||
private int _end; // \u0008
|
||||
|
||||
// Token: 0x04000038 RID: 56
|
||||
private int _size; // \u0006
|
||||
|
||||
// Token: 0x04000039 RID: 57
|
||||
private bool _internal; // \u000E
|
||||
|
||||
// Token: 0x0400003A RID: 58
|
||||
private bool _writable; // \u000F
|
||||
|
||||
// Token: 0x0400003B RID: 59
|
||||
private bool _valid; // \u0002\u2000
|
||||
|
||||
// Token: 0x0400003C RID: 60
|
||||
private bool _disposed; // \u0003\u2000
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,563 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Text;
|
||||
using forms_cil;
|
||||
|
||||
namespace UnitTestProject.RefVm
|
||||
{
|
||||
// Token: 0x0200000A RID: 10
|
||||
internal sealed class MyBufferReader : IDisposable // \u0002\u2007
|
||||
{
|
||||
// Token: 0x0400000C RID: 12
|
||||
private MyBuffer _src; // \u0002
|
||||
|
||||
// Token: 0x0400000D RID: 13
|
||||
private byte[] _inputRawBuf; // \u0003
|
||||
|
||||
// Token: 0x0400000E RID: 14
|
||||
private Decoder _decoder; // \u0005
|
||||
|
||||
// Token: 0x0400000F RID: 15
|
||||
private byte[] _inputCharRawBuf; // \u0008
|
||||
|
||||
// Token: 0x04000010 RID: 16
|
||||
private char[] _inputCharsDecoded; // \u0006
|
||||
|
||||
// Token: 0x04000011 RID: 17
|
||||
private char[] _stringChunk; // \u000E
|
||||
|
||||
// Token: 0x04000012 RID: 18
|
||||
private readonly int _maxCharsIn128Bytes; // \u000F
|
||||
|
||||
// Token: 0x04000013 RID: 19
|
||||
private readonly bool _isUnicode; // \u0002\u2000
|
||||
|
||||
// Token: 0x04000014 RID: 20
|
||||
private readonly bool _alwaysTrue; // \u0003\u2000
|
||||
|
||||
// Token: 0x06000034 RID: 52 RVA: 0x000027C8 File Offset: 0x000009C8
|
||||
public MyBufferReader(MyBuffer src) : this(src, new UTF8Encoding())
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x06000035 RID: 53 RVA: 0x000027D8 File Offset: 0x000009D8
|
||||
private MyBufferReader(MyBuffer src, Encoding encoding)
|
||||
{
|
||||
if (src == null)
|
||||
{
|
||||
throw new ArgumentNullException();
|
||||
}
|
||||
if (encoding == null)
|
||||
{
|
||||
throw new ArgumentNullException();
|
||||
}
|
||||
if (!src.IsValid())
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
_src = src;
|
||||
_decoder = encoding.GetDecoder();
|
||||
_maxCharsIn128Bytes = encoding.GetMaxCharCount(128);
|
||||
var num = encoding.GetMaxByteCount(1);
|
||||
if (num < 16)
|
||||
num = 16;
|
||||
_inputRawBuf = new byte[num];
|
||||
_stringChunk = null;
|
||||
_inputCharRawBuf = null;
|
||||
_isUnicode = (encoding is UnicodeEncoding);
|
||||
_alwaysTrue = (_src != null);
|
||||
}
|
||||
|
||||
// Token: 0x06000036 RID: 54 RVA: 0x00002878 File Offset: 0x00000A78
|
||||
public MyBuffer GetBuffer() // \u0002
|
||||
{
|
||||
return _src;
|
||||
}
|
||||
|
||||
// Token: 0x06000037 RID: 55 RVA: 0x00002880 File Offset: 0x00000A80
|
||||
public void Dispose() // \u0002
|
||||
{
|
||||
DoDispose(true);
|
||||
}
|
||||
|
||||
// Token: 0x06000038 RID: 56 RVA: 0x0000288C File Offset: 0x00000A8C
|
||||
private void DoDispose(bool disposing) // \u0002
|
||||
{
|
||||
if (disposing)
|
||||
_src?.DoDispose();
|
||||
_src = null;
|
||||
_inputRawBuf = null;
|
||||
_decoder = null;
|
||||
_inputCharRawBuf = null;
|
||||
_inputCharsDecoded = null;
|
||||
_stringChunk = null;
|
||||
}
|
||||
|
||||
// Token: 0x06000039 RID: 57 RVA: 0x000028E0 File Offset: 0x00000AE0
|
||||
void IDisposable.Dispose() // \u0002\u2007\u2008\u2000\u2002\u200A\u0003
|
||||
{
|
||||
DoDispose(true);
|
||||
}
|
||||
|
||||
// Token: 0x0600003A RID: 58 RVA: 0x000028EC File Offset: 0x00000AEC
|
||||
public int PeekUnicodeChar() // \u0002
|
||||
{
|
||||
SrcPrecondition();
|
||||
if (!_src.IsValid2())
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
var pos = _src.GetPos();
|
||||
var ret = SafeReadUnicodeChar();
|
||||
_src.SetPos(pos);
|
||||
return ret;
|
||||
}
|
||||
|
||||
// Token: 0x06000051 RID: 81 RVA: 0x00002FE8 File Offset: 0x000011E8
|
||||
private void SrcPrecondition() // \u0005
|
||||
{
|
||||
if (_src == null)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x0600003B RID: 59 RVA: 0x0000292C File Offset: 0x00000B2C
|
||||
public int SafeReadUnicodeChar() // \u0003
|
||||
{
|
||||
SrcPrecondition();
|
||||
return ReadUnicodeChar();
|
||||
}
|
||||
|
||||
// Token: 0x0600004E RID: 78 RVA: 0x00002E38 File Offset: 0x00001038
|
||||
private int ReadUnicodeChar() // \u0005
|
||||
{
|
||||
var charCnt = 0;
|
||||
var savedPos = 0L;
|
||||
if (_src.IsValid2())
|
||||
{
|
||||
savedPos = _src.GetPos();
|
||||
}
|
||||
if (_inputCharRawBuf == null)
|
||||
{
|
||||
_inputCharRawBuf = new byte[128];
|
||||
}
|
||||
if (_inputCharsDecoded == null)
|
||||
{
|
||||
_inputCharsDecoded = new char[1];
|
||||
}
|
||||
while (charCnt == 0)
|
||||
{
|
||||
var bytesToRead = _isUnicode ? 2 : 1;
|
||||
var b = _src.ReadByte();
|
||||
_inputCharRawBuf[0] = (byte)b;
|
||||
if (b == -1)
|
||||
{
|
||||
bytesToRead = 0;
|
||||
}
|
||||
if (bytesToRead == 2)
|
||||
{
|
||||
b = _src.ReadByte();
|
||||
_inputCharRawBuf[1] = (byte)b;
|
||||
if (b == -1)
|
||||
{
|
||||
bytesToRead = 1;
|
||||
}
|
||||
}
|
||||
if (bytesToRead == 0)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
try
|
||||
{
|
||||
charCnt = _decoder.GetChars(_inputCharRawBuf, 0, bytesToRead, _inputCharsDecoded, 0);
|
||||
}
|
||||
catch
|
||||
{
|
||||
if (_src.IsValid2())
|
||||
{
|
||||
_src.Seek(savedPos - _src.GetPos(), SeekOrigin.Current);
|
||||
}
|
||||
throw;
|
||||
}
|
||||
}
|
||||
if (charCnt == 0)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
return _inputCharsDecoded[0];
|
||||
}
|
||||
|
||||
// Token: 0x06000053 RID: 83 RVA: 0x0000305C File Offset: 0x0000125C
|
||||
private void ReadToRawBuf(int cnt) // \u0002
|
||||
{
|
||||
SrcPrecondition();
|
||||
var offset = 0;
|
||||
int bytesRead;
|
||||
if (cnt != 1)
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
bytesRead = _src.Read(_inputRawBuf, offset, cnt - offset);
|
||||
if (bytesRead == 0)
|
||||
break;
|
||||
offset += bytesRead;
|
||||
if (offset >= cnt)
|
||||
return;
|
||||
}
|
||||
throw new Exception();
|
||||
}
|
||||
bytesRead = _src.ReadByte();
|
||||
if (bytesRead == -1)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
_inputRawBuf[0] = (byte)bytesRead;
|
||||
}
|
||||
|
||||
// Token: 0x0600003C RID: 60 RVA: 0x0000293C File Offset: 0x00000B3C
|
||||
public bool ReadByteInternal() // \u0002
|
||||
{
|
||||
ReadToRawBuf(1);
|
||||
return _inputRawBuf[0] > 0;
|
||||
}
|
||||
|
||||
// Token: 0x0600003D RID: 61 RVA: 0x00002950 File Offset: 0x00000B50
|
||||
public byte ReadByte() // \u0002
|
||||
{
|
||||
SrcPrecondition();
|
||||
var b = _src.ReadByte();
|
||||
if (b == -1)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
return (byte)b;
|
||||
}
|
||||
|
||||
// Token: 0x0600003E RID: 62 RVA: 0x00002970 File Offset: 0x00000B70
|
||||
public sbyte ReadSbyte() // \u0002
|
||||
{
|
||||
ReadToRawBuf(1);
|
||||
return (sbyte)_inputRawBuf[0];
|
||||
}
|
||||
|
||||
// Token: 0x0600003F RID: 63 RVA: 0x00002984 File Offset: 0x00000B84
|
||||
public char ReadChar() // \u0002
|
||||
{
|
||||
var c = SafeReadUnicodeChar();
|
||||
if (c == -1)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
return (char)c;
|
||||
}
|
||||
|
||||
// Token: 0x06000040 RID: 64 RVA: 0x00002998 File Offset: 0x00000B98
|
||||
public short ReadShort() // \u0002
|
||||
{
|
||||
ReadToRawBuf(2);
|
||||
return (short)(_inputRawBuf[0] | _inputRawBuf[1] << 8);
|
||||
}
|
||||
|
||||
// Token: 0x06000041 RID: 65 RVA: 0x000029B8 File Offset: 0x00000BB8
|
||||
public ushort ReadUshort() // \u0002
|
||||
{
|
||||
ReadToRawBuf(2);
|
||||
return (ushort)(_inputRawBuf[0] | _inputRawBuf[1] << 8);
|
||||
}
|
||||
|
||||
// Token: 0x06000042 RID: 66 RVA: 0x000029D8 File Offset: 0x00000BD8
|
||||
public uint ReadUint() // \u0002
|
||||
{
|
||||
ReadToRawBuf(4);
|
||||
return (uint)(_inputRawBuf[0] | _inputRawBuf[1] << 8 | _inputRawBuf[2] << 16 | _inputRawBuf[3] << 24);
|
||||
}
|
||||
|
||||
// Token: 0x06000043 RID: 67 RVA: 0x00002A0C File Offset: 0x00000C0C
|
||||
public long ReadLong() // \u0002
|
||||
{
|
||||
ReadToRawBuf(8);
|
||||
var num = (uint)(_inputRawBuf[0] | _inputRawBuf[1] << 8 | _inputRawBuf[2] << 16 | _inputRawBuf[3] << 24);
|
||||
return (long)((ulong)(_inputRawBuf[4] | _inputRawBuf[5] << 8 | _inputRawBuf[6] << 16 | _inputRawBuf[7] << 24) << 32 | num);
|
||||
}
|
||||
|
||||
// Token: 0x06000044 RID: 68 RVA: 0x00002A80 File Offset: 0x00000C80
|
||||
public ulong ReadUlong() // \u0002
|
||||
{
|
||||
ReadToRawBuf(8);
|
||||
var num = (uint)(_inputRawBuf[0] | _inputRawBuf[1] << 8 | _inputRawBuf[2] << 16 | _inputRawBuf[3] << 24);
|
||||
return (ulong)(_inputRawBuf[4] | _inputRawBuf[5] << 8 | _inputRawBuf[6] << 16 | _inputRawBuf[7] << 24) << 32 | num;
|
||||
}
|
||||
|
||||
// Token: 0x06000045 RID: 69 RVA: 0x00002AF4 File Offset: 0x00000CF4
|
||||
private BinaryReader ReaderFor(int cnt) // \u0002
|
||||
{
|
||||
ReadToRawBuf(cnt);
|
||||
return new BinaryReader(new MemoryStream(_inputRawBuf, 0, cnt, false));
|
||||
}
|
||||
|
||||
// Token: 0x06000046 RID: 70 RVA: 0x00002B10 File Offset: 0x00000D10
|
||||
public float ReadFloat() // \u0002
|
||||
{
|
||||
var r = ReaderFor(4);
|
||||
var result = r.ReadSingle();
|
||||
r.Close();
|
||||
return result;
|
||||
}
|
||||
|
||||
// Token: 0x06000047 RID: 71 RVA: 0x00002B34 File Offset: 0x00000D34
|
||||
public double ReadDouble() // \u0002
|
||||
{
|
||||
var r = ReaderFor(8);
|
||||
var result = r.ReadDouble();
|
||||
r.Close();
|
||||
return result;
|
||||
}
|
||||
|
||||
// Token: 0x06000048 RID: 72 RVA: 0x00002B58 File Offset: 0x00000D58
|
||||
private static decimal CreateDecimal(int lo, int mid, int hi, int scaleNeg) // \u0002
|
||||
{
|
||||
var isNegative = (scaleNeg & -2147483648) != 0;
|
||||
var scale = (byte)(scaleNeg >> 16);
|
||||
return new decimal(lo, mid, hi, isNegative, scale);
|
||||
}
|
||||
|
||||
// Token: 0x06000049 RID: 73 RVA: 0x00002B80 File Offset: 0x00000D80
|
||||
internal static decimal CreateDecimal(byte[] b) // b
|
||||
{
|
||||
var lo = b[0] | b[1] << 8 | b[2] << 16 | b[3] << 24;
|
||||
var mid = b[4] | b[5] << 8 | b[6] << 16 | b[7] << 24;
|
||||
var hi = b[8] | b[9] << 8 | b[10] << 16 | b[11] << 24;
|
||||
var scaleNeg = b[12] | b[13] << 8 | b[14] << 16 | b[15] << 24;
|
||||
return CreateDecimal(lo, mid, hi, scaleNeg);
|
||||
}
|
||||
|
||||
// Token: 0x0600004A RID: 74 RVA: 0x00002BFC File Offset: 0x00000DFC
|
||||
public decimal ReadDecimal() // \u0002
|
||||
{
|
||||
ReadToRawBuf(16);
|
||||
return CreateDecimal(_inputRawBuf);
|
||||
}
|
||||
|
||||
// Token: 0x0600004B RID: 75 RVA: 0x00002C14 File Offset: 0x00000E14
|
||||
public string ReadString() // \u0002
|
||||
{
|
||||
var totalRead = 0;
|
||||
SrcPrecondition();
|
||||
var strLen = Read28Bit();
|
||||
if (strLen < 0)
|
||||
{
|
||||
throw new IOException();
|
||||
}
|
||||
if (strLen == 0)
|
||||
{
|
||||
return string.Empty;
|
||||
}
|
||||
if (_inputCharRawBuf == null)
|
||||
{
|
||||
_inputCharRawBuf = new byte[128];
|
||||
}
|
||||
if (_stringChunk == null)
|
||||
{
|
||||
_stringChunk = new char[_maxCharsIn128Bytes];
|
||||
}
|
||||
StringBuilder stringBuilder = null;
|
||||
while (true)
|
||||
{
|
||||
var needChunkCnt = (strLen - totalRead > 128) ? 128 : (strLen - totalRead);
|
||||
var realChunkRead = _src.Read(_inputCharRawBuf, 0, needChunkCnt);
|
||||
if (realChunkRead == 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
var chars = _decoder.GetChars(_inputCharRawBuf, 0, realChunkRead, _stringChunk, 0);
|
||||
if (totalRead == 0 && realChunkRead == strLen)
|
||||
{
|
||||
return new string(_stringChunk, 0, chars);
|
||||
}
|
||||
if (stringBuilder == null)
|
||||
{
|
||||
stringBuilder = new StringBuilder(strLen);
|
||||
}
|
||||
stringBuilder.Append(_stringChunk, 0, chars);
|
||||
totalRead += realChunkRead;
|
||||
if (totalRead >= strLen)
|
||||
{
|
||||
return stringBuilder.ToString();
|
||||
}
|
||||
}
|
||||
throw new Exception();
|
||||
}
|
||||
|
||||
// Token: 0x0600004C RID: 76 RVA: 0x00002D08 File Offset: 0x00000F08
|
||||
public int Read(char[] dest, int offset, int cnt) // \u0002
|
||||
{
|
||||
if (dest == null)
|
||||
{
|
||||
throw new ArgumentNullException(StringDecryptor.GetString(-1550347170), /* \u0002 */
|
||||
StringDecryptor.GetString(-1550347157) /* ArgumentNull_Buffer */);
|
||||
}
|
||||
if (offset < 0)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
if (cnt < 0)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
if (dest.Length - offset < cnt)
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
SrcPrecondition();
|
||||
return DoRead(dest, offset, cnt);
|
||||
}
|
||||
|
||||
// Token: 0x0600004D RID: 77 RVA: 0x00002D64 File Offset: 0x00000F64
|
||||
private int DoRead(char[] dest, int offset, int cnt) // \u0003
|
||||
{
|
||||
var remainCharsToRead = cnt;
|
||||
if (_inputCharRawBuf == null)
|
||||
{
|
||||
_inputCharRawBuf = new byte[128];
|
||||
}
|
||||
while (remainCharsToRead > 0)
|
||||
{
|
||||
var chunkSize = remainCharsToRead;
|
||||
if (_isUnicode)
|
||||
{
|
||||
chunkSize <<= 1;
|
||||
}
|
||||
if (chunkSize > 128)
|
||||
{
|
||||
chunkSize = 128;
|
||||
}
|
||||
int chars;
|
||||
if (_alwaysTrue)
|
||||
{
|
||||
var byteIndex = _src.GetCursor();
|
||||
chunkSize = _src.SkipBytes(chunkSize);
|
||||
if (chunkSize == 0)
|
||||
{
|
||||
return cnt - remainCharsToRead;
|
||||
}
|
||||
chars = _decoder.GetChars(_src.Data(), byteIndex, chunkSize, dest, offset);
|
||||
}
|
||||
else
|
||||
{
|
||||
chunkSize = _src.Read(_inputCharRawBuf, 0, chunkSize);
|
||||
if (chunkSize == 0)
|
||||
{
|
||||
return cnt - remainCharsToRead;
|
||||
}
|
||||
chars = _decoder.GetChars(_inputCharRawBuf, 0, chunkSize, dest, offset);
|
||||
}
|
||||
remainCharsToRead -= chars;
|
||||
offset += chars;
|
||||
}
|
||||
return cnt;
|
||||
}
|
||||
|
||||
|
||||
// Token: 0x0600004F RID: 79 RVA: 0x00002F54 File Offset: 0x00001154
|
||||
public char[] ReadChars(int cnt) // \u0002
|
||||
{
|
||||
SrcPrecondition();
|
||||
if (cnt < 0)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
var ret = new char[cnt];
|
||||
var realLength = DoRead(ret, 0, cnt);
|
||||
if (realLength != cnt)
|
||||
{
|
||||
var shrinked = new char[realLength];
|
||||
Buffer.BlockCopy(ret, 0, shrinked, 0, 2 * realLength);
|
||||
ret = shrinked;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
// Token: 0x06000050 RID: 80 RVA: 0x00002F9C File Offset: 0x0000119C
|
||||
public int Read(byte[] dest, int offset, int cnt) // dest
|
||||
{
|
||||
if (dest == null)
|
||||
{
|
||||
throw new ArgumentNullException();
|
||||
}
|
||||
if (offset < 0)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
if (cnt < 0)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
if (dest.Length - offset < cnt)
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
SrcPrecondition();
|
||||
return _src.Read(dest, offset, cnt);
|
||||
}
|
||||
|
||||
// Token: 0x06000052 RID: 82 RVA: 0x00002FF8 File Offset: 0x000011F8
|
||||
public byte[] ReadBytes(int cnt) // \u0002
|
||||
{
|
||||
if (cnt < 0)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
SrcPrecondition();
|
||||
var ret = new byte[cnt];
|
||||
var offset = 0;
|
||||
do
|
||||
{
|
||||
var chunkSize = _src.Read(ret, offset, cnt);
|
||||
if (chunkSize == 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
offset += chunkSize;
|
||||
cnt -= chunkSize;
|
||||
}
|
||||
while (cnt > 0);
|
||||
if (offset != ret.Length)
|
||||
{
|
||||
var shrinked = new byte[offset];
|
||||
Buffer.BlockCopy(ret, 0, shrinked, 0, offset);
|
||||
ret = shrinked;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
// Token: 0x06000054 RID: 84 RVA: 0x000030C0 File Offset: 0x000012C0
|
||||
internal int Read28Bit() // \u0008
|
||||
{
|
||||
var ret = 0;
|
||||
var bitCnt = 0;
|
||||
while (bitCnt != 35)
|
||||
{
|
||||
var b = ReadByte();
|
||||
ret |= (b & 127) << bitCnt;
|
||||
bitCnt += 7;
|
||||
if ((b & 128) == 0)
|
||||
{
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
throw new FormatException();
|
||||
}
|
||||
|
||||
// Token: 0x06000055 RID: 85 RVA: 0x00003100 File Offset: 0x00001300
|
||||
public int ReadInt32() // \u0006
|
||||
{
|
||||
if (_alwaysTrue)
|
||||
{
|
||||
return _src.ReadInt32();
|
||||
}
|
||||
ReadToRawBuf(4);
|
||||
return _inputRawBuf[3] << 8 | _inputRawBuf[1] << 24 | _inputRawBuf[0] << 16 | _inputRawBuf[2];
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,361 @@
|
||||
using System;
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading;
|
||||
|
||||
namespace UnitTestProject.RefVm
|
||||
{
|
||||
// Token: 0x02000006 RID: 6
|
||||
internal static class EmptyArray<T> // \u0002\u2003
|
||||
{
|
||||
// Token: 0x04000004 RID: 4
|
||||
public static readonly T[] Data = new T[0];
|
||||
}
|
||||
|
||||
// Token: 0x02000022 RID: 34
|
||||
internal sealed class MyCollection<T> : IEnumerable<T>, ICollection // \u0005\u2006
|
||||
{
|
||||
// Token: 0x0400002C RID: 44
|
||||
internal T[] Data; // \u0002
|
||||
|
||||
// Token: 0x0400002E RID: 46
|
||||
internal int ChangeCounter; // \u0005
|
||||
|
||||
// Token: 0x0400002F RID: 47
|
||||
private object _sync; // \u0008
|
||||
|
||||
// Token: 0x060000DA RID: 218 RVA: 0x00004B9C File Offset: 0x00002D9C
|
||||
public MyCollection()
|
||||
{
|
||||
Data = EmptyArray<T>.Data;
|
||||
Count = 0;
|
||||
ChangeCounter = 0;
|
||||
}
|
||||
|
||||
// Token: 0x060000DB RID: 219 RVA: 0x00004BC0 File Offset: 0x00002DC0
|
||||
public MyCollection(int capacity)
|
||||
{
|
||||
if (capacity < 0)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
Data = new T[capacity];
|
||||
Count = 0;
|
||||
ChangeCounter = 0;
|
||||
}
|
||||
|
||||
// Token: 0x060000DC RID: 220 RVA: 0x00004BEC File Offset: 0x00002DEC
|
||||
public MyCollection(IEnumerable<T> src)
|
||||
{
|
||||
if (src == null)
|
||||
{
|
||||
throw new ArgumentNullException();
|
||||
}
|
||||
var collection = src as ICollection<T>;
|
||||
if (collection != null)
|
||||
{
|
||||
var count = collection.Count;
|
||||
Data = new T[count];
|
||||
collection.CopyTo(Data, 0);
|
||||
Count = count;
|
||||
return;
|
||||
}
|
||||
Count = 0;
|
||||
Data = new T[4];
|
||||
foreach (var i in Data)
|
||||
{
|
||||
PushBack(i);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x0400002D RID: 45
|
||||
// Token: 0x17000006 RID: 6
|
||||
// (get) Token: 0x060000DD RID: 221 RVA: 0x00004C88 File Offset: 0x00002E88
|
||||
public int Count { get; private set; } // \u0003
|
||||
|
||||
// Token: 0x060000DE RID: 222 RVA: 0x00004C90 File Offset: 0x00002E90
|
||||
bool ICollection.IsSynchronized => false; // \u0005\u2006\u2008\u2000\u2002\u200A\u0002
|
||||
|
||||
// Token: 0x060000DF RID: 223 RVA: 0x00004C94 File Offset: 0x00002E94
|
||||
object ICollection.SyncRoot // \u0005\u2006\u2008\u2000\u2002\u200A\u0002
|
||||
{
|
||||
get
|
||||
{
|
||||
if (_sync == null)
|
||||
{
|
||||
Interlocked.CompareExchange(ref _sync, new object(), null);
|
||||
}
|
||||
return _sync;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060000E0 RID: 224 RVA: 0x00004CB8 File Offset: 0x00002EB8
|
||||
public void Clear() // \u0002
|
||||
{
|
||||
Array.Clear(Data, 0, Count);
|
||||
Count = 0;
|
||||
ChangeCounter++;
|
||||
}
|
||||
|
||||
// Token: 0x060000E1 RID: 225 RVA: 0x00004CE4 File Offset: 0x00002EE4
|
||||
public bool Contains(T what) // \u0002
|
||||
{
|
||||
var num = Count;
|
||||
var @default = EqualityComparer<T>.Default;
|
||||
while (num-- > 0)
|
||||
{
|
||||
if (what == null)
|
||||
{
|
||||
if (Data[num] == null)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
else if (Data[num] != null && @default.Equals(Data[num], what))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Token: 0x060000E2 RID: 226 RVA: 0x00004D50 File Offset: 0x00002F50
|
||||
public void CopyTo(T[] dest, int offset) // \u0003
|
||||
{
|
||||
if (dest == null)
|
||||
{
|
||||
throw new ArgumentNullException(StringDecryptor.GetString(-1550346880) /* \u0002 */);
|
||||
}
|
||||
if (offset < 0 || offset > dest.Length)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException(StringDecryptor.GetString(-1550346867) /* \u0003 */,
|
||||
StringDecryptor.GetString(-1550346858) /* arrayIndex < 0 || arrayIndex > array.Length */);
|
||||
}
|
||||
if (dest.Length - offset < Count)
|
||||
{
|
||||
throw new ArgumentException(StringDecryptor.GetString(-1550347192) /* Invalid Off Len */);
|
||||
}
|
||||
Array.Copy(Data, 0, dest, offset, Count);
|
||||
Array.Reverse(dest, offset, Count);
|
||||
}
|
||||
|
||||
// Token: 0x060000E3 RID: 227 RVA: 0x00004DD4 File Offset: 0x00002FD4
|
||||
void ICollection.CopyTo(Array dest, int offset) // \u0005\u2006\u2008\u2000\u2002\u200A\u0002
|
||||
{
|
||||
if (dest == null)
|
||||
{
|
||||
throw new ArgumentNullException();
|
||||
}
|
||||
if (dest.Rank != 1)
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
if (dest.GetLowerBound(0) != 0)
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
if (offset < 0 || offset > dest.Length)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException();
|
||||
}
|
||||
if (dest.Length - offset < Count)
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
try
|
||||
{
|
||||
Array.Copy(Data, 0, dest, offset, Count);
|
||||
Array.Reverse(dest, offset, Count);
|
||||
}
|
||||
catch (ArrayTypeMismatchException)
|
||||
{
|
||||
throw new ArgumentException();
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060000E4 RID: 228 RVA: 0x00004E6C File Offset: 0x0000306C
|
||||
public MyEnumerator<T> GetEnumerator() // \u0005
|
||||
{
|
||||
return new MyEnumerator<T>(this);
|
||||
}
|
||||
|
||||
// Token: 0x060000E5 RID: 229 RVA: 0x00004E74 File Offset: 0x00003074
|
||||
IEnumerator<T> IEnumerable<T>.GetEnumerator() // \u0005\u2006\u2008\u2000\u2002\u200A\u0008
|
||||
{
|
||||
return new MyEnumerator<T>(this);
|
||||
}
|
||||
|
||||
// Token: 0x060000E6 RID: 230 RVA: 0x00004E84 File Offset: 0x00003084
|
||||
IEnumerator IEnumerable.GetEnumerator() // \u0005\u2006\u2008\u2000\u2002\u200A\u0002
|
||||
{
|
||||
return new MyEnumerator<T>(this);
|
||||
}
|
||||
|
||||
// Token: 0x060000E7 RID: 231 RVA: 0x00004E94 File Offset: 0x00003094
|
||||
public void Shrink() // \u0003
|
||||
{
|
||||
var num = (int)(Data.Length * 0.9);
|
||||
if (Count < num)
|
||||
{
|
||||
var destinationArray = new T[Count];
|
||||
Array.Copy(Data, 0, destinationArray, 0, Count);
|
||||
Data = destinationArray;
|
||||
ChangeCounter++;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060000E8 RID: 232 RVA: 0x00004EF4 File Offset: 0x000030F4
|
||||
public T PeekBack() // \u0006
|
||||
{
|
||||
if (Count == 0)
|
||||
{
|
||||
throw new InvalidOperationException();
|
||||
}
|
||||
return Data[Count - 1];
|
||||
}
|
||||
|
||||
// Token: 0x060000E9 RID: 233 RVA: 0x00004F18 File Offset: 0x00003118
|
||||
public T PopBack() // \u000E
|
||||
{
|
||||
if (Count == 0)
|
||||
{
|
||||
throw new InvalidOperationException();
|
||||
}
|
||||
ChangeCounter++;
|
||||
var ret = Data[--Count];
|
||||
Data[Count] = default(T);
|
||||
return ret;
|
||||
}
|
||||
|
||||
// Token: 0x060000EA RID: 234 RVA: 0x00004F78 File Offset: 0x00003178
|
||||
public void PushBack(T obj) // \u000F
|
||||
{
|
||||
if (Count == Data.Length)
|
||||
{
|
||||
var destinationArray = new T[(Data.Length == 0) ? 4 : (2 * Data.Length)];
|
||||
Array.Copy(Data, 0, destinationArray, 0, Count);
|
||||
Data = destinationArray;
|
||||
}
|
||||
var num = Count;
|
||||
Count = num + 1;
|
||||
Data[num] = obj;
|
||||
ChangeCounter++;
|
||||
}
|
||||
|
||||
// Token: 0x060000EB RID: 235 RVA: 0x00004FF8 File Offset: 0x000031F8
|
||||
public T[] Reverse() // \u0002\u2000
|
||||
{
|
||||
var array = new T[Count];
|
||||
for (var i = 0; i < Count; i++)
|
||||
{
|
||||
array[i] = Data[Count - i - 1];
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
// Token: 0x02000023 RID: 35
|
||||
public struct MyEnumerator<T1> : IEnumerator<T1> // \u0002
|
||||
{
|
||||
// Token: 0x060000EC RID: 236 RVA: 0x00005040 File Offset: 0x00003240
|
||||
internal MyEnumerator(MyCollection<T1> src)
|
||||
{
|
||||
_src = src;
|
||||
_changeCounter = _src.ChangeCounter;
|
||||
_curPos = -2;
|
||||
_current = default(T1);
|
||||
}
|
||||
|
||||
// Token: 0x060000ED RID: 237 RVA: 0x00005070 File Offset: 0x00003270
|
||||
public void Dispose()
|
||||
{
|
||||
_curPos = -1;
|
||||
}
|
||||
|
||||
// Token: 0x060000EE RID: 238 RVA: 0x0000507C File Offset: 0x0000327C
|
||||
public bool MoveNext()
|
||||
{
|
||||
if (_changeCounter != _src.ChangeCounter)
|
||||
{
|
||||
throw new InvalidOperationException(StringDecryptor.GetString(-1550346776) /* EnumFailedVersion */);
|
||||
}
|
||||
if (_curPos == -2)
|
||||
{
|
||||
_curPos = _src.Count - 1;
|
||||
if (_curPos < 0) return false;
|
||||
_current = _src.Data[_curPos];
|
||||
return true;
|
||||
}
|
||||
if (_curPos == -1)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (--_curPos >= 0)
|
||||
{
|
||||
_current = _src.Data[_curPos];
|
||||
return true;
|
||||
}
|
||||
_current = default(T1);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Token: 0x17000007 RID: 7
|
||||
// (get) Token: 0x060000EF RID: 239 RVA: 0x00005144 File Offset: 0x00003344
|
||||
public T1 Current
|
||||
{
|
||||
get
|
||||
{
|
||||
if (_curPos == -2)
|
||||
{
|
||||
throw new InvalidOperationException();
|
||||
}
|
||||
if (_curPos == -1)
|
||||
{
|
||||
throw new InvalidOperationException();
|
||||
}
|
||||
return _current;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060000F0 RID: 240 RVA: 0x0000516C File Offset: 0x0000336C
|
||||
object IEnumerator.Current // \u0002\u2008\u2000\u2002\u200A\u0002
|
||||
{
|
||||
get
|
||||
{
|
||||
if (_curPos == -2)
|
||||
{
|
||||
throw new InvalidOperationException();
|
||||
}
|
||||
if (_curPos == -1)
|
||||
{
|
||||
throw new InvalidOperationException();
|
||||
}
|
||||
return _current;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060000F1 RID: 241 RVA: 0x00005198 File Offset: 0x00003398
|
||||
void IEnumerator.Reset() // \u0002\u2008\u2000\u2002\u200A\u0002
|
||||
{
|
||||
if (_changeCounter != _src.ChangeCounter)
|
||||
{
|
||||
throw new InvalidOperationException();
|
||||
}
|
||||
_curPos = -2;
|
||||
_current = default(T1);
|
||||
}
|
||||
|
||||
// Token: 0x04000030 RID: 48
|
||||
private readonly MyCollection<T1> _src; // \u0002
|
||||
|
||||
// Token: 0x04000031 RID: 49
|
||||
private int _curPos; // \u0003
|
||||
|
||||
// Token: 0x04000032 RID: 50
|
||||
private readonly int _changeCounter; // \u0005
|
||||
|
||||
// Token: 0x04000033 RID: 51
|
||||
private T1 _current; // \u0008
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,288 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.Reflection;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Text;
|
||||
|
||||
namespace UnitTestProject.RefVm
|
||||
{
|
||||
// Token: 0x02000063 RID: 99
|
||||
internal static class SdMetadataTokens // \u000F\u2009
|
||||
{
|
||||
// Token: 0x06000399 RID: 921 RVA: 0x00015D18 File Offset: 0x00013F18
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
internal static long GetLong() // \u0002
|
||||
{
|
||||
if (Assembly.GetCallingAssembly() != typeof(SdMetadataTokens).Assembly || !CheckStack())
|
||||
{
|
||||
return 0L;
|
||||
}
|
||||
long result;
|
||||
lock (Obj)
|
||||
{
|
||||
var num = Obj.GetLong7();
|
||||
if (num == 0L)
|
||||
{
|
||||
var executingAssembly = Assembly.GetExecutingAssembly();
|
||||
var list = new List<byte>();
|
||||
AssemblyName assemblyName;
|
||||
try
|
||||
{
|
||||
assemblyName = executingAssembly.GetName();
|
||||
}
|
||||
catch
|
||||
{
|
||||
assemblyName = new AssemblyName(executingAssembly.FullName);
|
||||
}
|
||||
var array = assemblyName.GetPublicKeyToken();
|
||||
if (array != null && array.Length == 0)
|
||||
{
|
||||
array = null;
|
||||
}
|
||||
if (array != null)
|
||||
{
|
||||
list.AddRange(array);
|
||||
}
|
||||
list.AddRange(Encoding.Unicode.GetBytes(assemblyName.Name));
|
||||
var num2 = 0x02000063; //GetMdt(typeof(SdMetadataTokens));
|
||||
var num3 = Class1.M();
|
||||
list.Add((byte)(num2 >> 24));
|
||||
list.Add((byte)(num3 >> 16));
|
||||
list.Add((byte)(num2 >> 8));
|
||||
list.Add((byte)num3);
|
||||
list.Add((byte)(num2 >> 16));
|
||||
list.Add((byte)(num3 >> 8));
|
||||
list.Add((byte)num2);
|
||||
list.Add((byte)(num3 >> 24));
|
||||
var count = list.Count;
|
||||
var num4 = 0uL;
|
||||
for (var num5 = 0; num5 != count; num5++)
|
||||
{
|
||||
num4 += list[num5];
|
||||
num4 += num4 << 20;
|
||||
num4 ^= num4 >> 12;
|
||||
list[num5] = 0;
|
||||
}
|
||||
num4 += num4 << 6;
|
||||
num4 ^= num4 >> 22;
|
||||
num4 += num4 << 30;
|
||||
num = (long)num4;
|
||||
num ^= 7895633081549295753L;
|
||||
Obj.SetLong(num);
|
||||
}
|
||||
result = num;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// Token: 0x0600039A RID: 922 RVA: 0x00015EE0 File Offset: 0x000140E0
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
private static bool CheckStack() // \u0002
|
||||
{
|
||||
return CheckStackImpl();
|
||||
}
|
||||
|
||||
// Token: 0x0600039B RID: 923 RVA: 0x00015EEC File Offset: 0x000140EC
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
private static bool CheckStackImpl() // \u0003
|
||||
{
|
||||
var stackTrace = new StackTrace();
|
||||
var frame = stackTrace.GetFrame(3);
|
||||
var methodBase = frame?.GetMethod();
|
||||
var type = methodBase?.DeclaringType;
|
||||
return type != typeof(RuntimeMethodHandle) && type != null && type.Assembly == typeof(SdMetadataTokens).Assembly;
|
||||
}
|
||||
|
||||
// Token: 0x0600039C RID: 924 RVA: 0x00015F50 File Offset: 0x00014150
|
||||
// ReSharper disable once UnusedMember.Local
|
||||
private static int GetMdt(Type t) // \u0002
|
||||
{
|
||||
return t.MetadataToken;
|
||||
}
|
||||
|
||||
// Token: 0x0400019A RID: 410
|
||||
// \u0002
|
||||
private static readonly Class7 Obj = new Class7();
|
||||
|
||||
// Token: 0x02000064 RID: 100
|
||||
public sealed class Class1 // \u0002\u2007\u2007\u2009\u2002\u2006\u2003\u2003\u2002\u2004\u2007\u200A\u2009\u200A\u2008\u200A\u2000\u2003\u200B\u2007\u200A\u2008\u200A\u2003\u2006\u200B
|
||||
{
|
||||
// Token: 0x0600039E RID: 926 RVA: 0x00015F60 File Offset: 0x00014160
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
internal static int M()
|
||||
{
|
||||
return Class2.M3(Class2.M2(0x02000067 /*GetMdt(typeof(Class4))*/, Class2.M3(0x02000064 /*GetMdt(typeof(Class1))*/, 0x02000066 /*GetMdt(typeof(Class3))*/)), Class5.M1());
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x02000065 RID: 101
|
||||
private static class Class2 // \u0002\u200A\u2003\u2000\u2002\u2000\u2007\u2008\u2004\u2006\u2007\u2003\u2007\u2004\u2000\u2003\u2009\u2007\u2003\u2006\u2007\u2008\u200A
|
||||
{
|
||||
// Token: 0x0600039F RID: 927 RVA: 0x00015FB0 File Offset: 0x000141B0
|
||||
internal static int M1(int p1, int p2) // \u0002
|
||||
{
|
||||
return p1 ^ p2 - -~~- -~~- -~~-1683504797;
|
||||
}
|
||||
|
||||
// Token: 0x060003A0 RID: 928 RVA: 0x00015FC8 File Offset: 0x000141C8
|
||||
internal static int M2(int p1, int p2) // \u0003
|
||||
{
|
||||
return p1 - -~-~-~~- -~~-1670271084 ^ p2 + -~-~-~~-~-~699406271;
|
||||
}
|
||||
|
||||
// Token: 0x060003A1 RID: 929 RVA: 0x00015FF0 File Offset: 0x000141F0
|
||||
internal static int M3(int p1, int p2) // \u0005
|
||||
{
|
||||
return p1 ^ p2 - -~~-~-~- -~~-1466097638 ^ p1 - p2;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x02000066 RID: 102
|
||||
public sealed class Class3 // \u0003\u2001\u2003\u2009\u2009\u2008\u2006\u2006\u2006\u200A\u2003\u2006\u2005\u2005\u2009\u200B\u2009\u200A\u2003\u2007
|
||||
{
|
||||
// Token: 0x060003A3 RID: 931 RVA: 0x00016014 File Offset: 0x00014214
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
internal static int M1() // \u0002
|
||||
{
|
||||
return Class2.M2(Class2.M2(Class6.M1(), Class2.M1(0x02000066 /*GetMdt(typeof(Class3))*/, Class4.M1())), 0x02000068 /*GetMdt(typeof(Class5))*/);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x02000067 RID: 103
|
||||
public sealed class Class4 // \u0003\u2007\u2006\u2000\u2001\u2003\u2006\u200B\u2003\u2009\u200B\u2008\u200A\u2008\u2004\u2005\u2006\u200A\u2008\u2000\u2000\u200B\u2008\u200A
|
||||
{
|
||||
// Token: 0x060003A5 RID: 933 RVA: 0x00016058 File Offset: 0x00014258
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
internal static int M1() // \u0002
|
||||
{
|
||||
return Class2.M1(0x02000069 /*GetMdt(typeof(Class6))*/, 0x0200006B /*GetMdt(typeof(Class8))*/ ^ Class2.M2(0x02000067 /*GetMdt(typeof(Class4))*/, Class2.M3(0x02000068 /*GetMdt(typeof(Class5))*/, Class8.M1())));
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x02000068 RID: 104
|
||||
public sealed class Class5 // \u0005\u2006\u200A\u2004\u200B\u2005\u200B\u2004\u2005\u2002\u2000\u2001\u2002\u2004\u2000\u2002\u2007\u2003\u2009\u200B\u2007\u200A\u200B\u2000\u2008\u2002\u2003\u2002
|
||||
{
|
||||
// Token: 0x060003A7 RID: 935 RVA: 0x000160C0 File Offset: 0x000142C0
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
internal static int M1() // \u0002
|
||||
{
|
||||
return Class2.M1(0x02000068 /*GetMdt(typeof(Class5))*/, Class2.M3(Class2.M2(0x02000066 /*GetMdt(typeof(Class3))*/, 0x02000064 /*GetMdt(typeof(Class1))*/), Class2.M3(0x02000069 /*GetMdt(typeof(Class6))*/ ^ -~-~~- -~~-1251689633, Class3.M1())));
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x02000069 RID: 105
|
||||
public sealed class Class6 // \u0008\u2007\u2007\u2004\u2006\u2006\u200A\u2009\u2005\u2006\u2008\u200A\u2000\u200A\u2008\u2002\u2009\u2003\u2006\u2008\u2000\u2005\u2004\u200A\u2004\u2008\u2008\u2001\u2004\u200B
|
||||
{
|
||||
// Token: 0x060003A9 RID: 937 RVA: 0x0001613C File Offset: 0x0001433C
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
internal static int M1() // \u0002
|
||||
{
|
||||
return Class2.M3(Class2.M1(Class4.M1() ^ ~-~- -~~- -~~-527758448, 0x0200006B /*GetMdt(typeof(Class8))*/), Class2.M2(0x02000064 /*GetMdt(typeof(Class1))*/ ^ 0x02000068 /*GetMdt(typeof(Class5))*/, -~~- -~-~~1892236202));
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x0200006A RID: 106
|
||||
internal sealed class Class7 // \u000F\u2005\u2007\u2007\u2009\u2009\u2002\u2004\u2008\u2009\u2002\u2000\u2000\u2009\u2009\u200B\u2008\u2004\u2003\u200B\u200A\u2002\u2002\u2003\u2006\u2007\u2000\u2006\u2002\u2003
|
||||
{
|
||||
// Token: 0x060003AA RID: 938 RVA: 0x000161AC File Offset: 0x000143AC
|
||||
internal Class7()
|
||||
{
|
||||
SetLong(0L);
|
||||
}
|
||||
|
||||
// Token: 0x060003AB RID: 939 RVA: 0x000161BC File Offset: 0x000143BC
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
public long GetLong7() // \u0002
|
||||
{
|
||||
if (Assembly.GetCallingAssembly() != typeof(Class7).Assembly)
|
||||
{
|
||||
return 2918384L;
|
||||
}
|
||||
if (!CheckStack())
|
||||
{
|
||||
return 2918384L;
|
||||
}
|
||||
var array = new[]
|
||||
{
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
-~~- -~-~~1688528055
|
||||
};
|
||||
array[1] = ~-~- -~~-~1937298816;
|
||||
array[2] = ~-~- -~-~~-~-2131774929;
|
||||
array[0] = ~-~-~- -~~-~859851913;
|
||||
var num = _i1;
|
||||
var num2 = _i2;
|
||||
var num3 = -~-~-~~-~1640531528;
|
||||
var num4 = -~-~~- -~~-~957401312;
|
||||
for (var num5 = 0; num5 != 32; num5++)
|
||||
{
|
||||
num2 -= (num << 4 ^ num >> 5) + num ^ num4 + array[num4 >> 11 & 3];
|
||||
num4 -= num3;
|
||||
num -= (num2 << 4 ^ num2 >> 5) + num2 ^ num4 + array[num4 & 3];
|
||||
}
|
||||
for (var num6 = 0; num6 != 4; num6++)
|
||||
{
|
||||
array[num6] = 0;
|
||||
}
|
||||
var num7 = ((ulong)num2 << 32);
|
||||
var n = (ulong)_i1;
|
||||
return (long)(num7 | n);
|
||||
}
|
||||
|
||||
// Token: 0x060003AC RID: 940 RVA: 0x000162D8 File Offset: 0x000144D8
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
internal void SetLong(long p) // \u0002
|
||||
{
|
||||
if (Assembly.GetCallingAssembly() != typeof(Class7).Assembly)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if (!CheckStack())
|
||||
{
|
||||
return;
|
||||
}
|
||||
var array = new int[4];
|
||||
array[1] = -~~-~- -~~-~1937298817;
|
||||
array[0] = -~~-~-~-~859851914;
|
||||
array[2] = ~-~- -~~-~-2131774930;
|
||||
array[3] = -~-~~-~- -~~1688528054;
|
||||
var num = -~-~~- -~-~~1640531529;
|
||||
var num2 = (int)p;
|
||||
var num3 = (int)(p >> 32);
|
||||
var num4 = 0;
|
||||
for (var num5 = 0; num5 != 32; num5++)
|
||||
{
|
||||
num2 += (num3 << 4 ^ num3 >> 5) + num3 ^ num4 + array[num4 & 3];
|
||||
num4 += num;
|
||||
num3 += (num2 << 4 ^ num2 >> 5) + num2 ^ num4 + array[num4 >> 11 & 3];
|
||||
}
|
||||
for (var num6 = 0; num6 != 4; num6++)
|
||||
{
|
||||
array[num6] = 0;
|
||||
}
|
||||
_i1 = num2;
|
||||
_i2 = num3;
|
||||
}
|
||||
|
||||
// Token: 0x0400019B RID: 411
|
||||
private int _i1; // \u0002
|
||||
|
||||
// Token: 0x0400019C RID: 412
|
||||
private int _i2; // \u0003
|
||||
}
|
||||
|
||||
// Token: 0x0200006B RID: 107
|
||||
public sealed class Class8 // \u000F\u200A\u2002\u2009\u2000\u2009\u2003\u200A\u2005\u2001\u2002\u2002\u2003\u200B\u2000\u2009\u2003\u2009\u2009\u2001\u2002\u200B\u2000\u200A
|
||||
{
|
||||
// Token: 0x060003AE RID: 942 RVA: 0x000163DC File Offset: 0x000145DC
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
internal static int M1()
|
||||
{
|
||||
return Class2.M3(0x0200006B /*GetMdt(typeof(Class8))*/, Class2.M1(0x02000064 /*GetMdt(typeof(Class1))*/, Class2.M2(0x02000067 /*GetMdt(typeof(Class4))*/, Class2.M3(0x02000069 /*GetMdt(typeof(Class6))*/, Class2.M1(0x02000066 /*GetMdt(typeof(Class3))*/, 0x02000068 /*GetMdt(typeof(Class5))*/)))));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,180 @@
|
||||
using System;
|
||||
using System.Threading;
|
||||
|
||||
namespace forms_cil
|
||||
{
|
||||
// Token: 0x02000057 RID: 87
|
||||
internal interface I4 // \u000E\u2008
|
||||
{
|
||||
// Token: 0x06000346 RID: 838
|
||||
bool I4M(); // \u000E\u2008\u2008\u2000\u2002\u200A\u0002
|
||||
|
||||
// Token: 0x06000347 RID: 839
|
||||
object M2(); // \u000E\u2008\u2008\u2000\u2002\u200A\u0002
|
||||
|
||||
// Token: 0x06000348 RID: 840
|
||||
void M3(); // \u000E\u2008\u2008\u2000\u2002\u200A\u0002
|
||||
}
|
||||
|
||||
// Token: 0x02000062 RID: 98
|
||||
internal interface I5 // \u000F\u2008
|
||||
{
|
||||
// Token: 0x06000397 RID: 919
|
||||
void I5M(); // \u000F\u2008\u2008\u2000\u2002\u200A\u0002
|
||||
}
|
||||
|
||||
// Token: 0x0200000C RID: 12
|
||||
internal interface I1<out T> : I4, I5 // \u0002\u2009
|
||||
{
|
||||
// Token: 0x06000057 RID: 87
|
||||
T I1M(); // \u000E\u2008\u2008\u2000\u2002\u200A\u0002
|
||||
}
|
||||
|
||||
// Token: 0x0200004B RID: 75
|
||||
internal interface I3 // \u0008\u2008
|
||||
{
|
||||
// Token: 0x0600031E RID: 798
|
||||
I4 M1(); // \u0008\u2008\u2008\u2000\u2002\u200A\u0002
|
||||
}
|
||||
|
||||
// Token: 0x0200003C RID: 60
|
||||
internal interface I2<out T> : I3 // \u0006\u2008
|
||||
{
|
||||
// Token: 0x060002CD RID: 717
|
||||
I1<T> I2M(); // \u0008\u2008\u2008\u2000\u2002\u200A\u0002
|
||||
}
|
||||
|
||||
// Token: 0x02000025 RID: 37
|
||||
internal static class SdTemplateStuff // \u0005\u2008
|
||||
{
|
||||
// Token: 0x02000026 RID: 38
|
||||
internal sealed class C : I2<int>, I1<int> // \u0002
|
||||
{
|
||||
// Token: 0x06000112 RID: 274 RVA: 0x00005A28 File Offset: 0x00003C28
|
||||
public C(int val)
|
||||
{
|
||||
_i2 = val;
|
||||
_i5 = Thread.CurrentThread.ManagedThreadId;
|
||||
}
|
||||
|
||||
// Token: 0x06000113 RID: 275 RVA: 0x00005A48 File Offset: 0x00003C48
|
||||
void I5.I5M()
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x06000114 RID: 276 RVA: 0x00005A4C File Offset: 0x00003C4C
|
||||
bool I4.I4M()
|
||||
{
|
||||
switch (_i2)
|
||||
{
|
||||
case 0:
|
||||
_i2 = -1;
|
||||
_i3 = -1496196691;
|
||||
_i2 = 1;
|
||||
return true;
|
||||
case 1:
|
||||
_i2 = -1;
|
||||
_i3 = _i8 ^ 70939052;
|
||||
_i2 = 2;
|
||||
return true;
|
||||
case 2:
|
||||
_i2 = -1;
|
||||
_i3 = _i8 ^ -1812634754;
|
||||
_i2 = 3;
|
||||
return true;
|
||||
case 3:
|
||||
_i2 = -1;
|
||||
_i3 = -5623460;
|
||||
_i2 = 4;
|
||||
return true;
|
||||
case 4:
|
||||
_i2 = -1;
|
||||
_i3 = 401181880;
|
||||
_i2 = 5;
|
||||
return true;
|
||||
case 5:
|
||||
_i2 = -1;
|
||||
_i3 = 2075948002;
|
||||
_i2 = 6;
|
||||
return true;
|
||||
case 6:
|
||||
_i2 = -1;
|
||||
_i3 = _i8 ^ 70939052;
|
||||
_i2 = 7;
|
||||
return true;
|
||||
case 7:
|
||||
_i2 = -1;
|
||||
_i3 = -783689628;
|
||||
_i2 = 8;
|
||||
return true;
|
||||
case 8:
|
||||
_i2 = -1;
|
||||
_i3 = _i8 ^ 70939052;
|
||||
_i2 = 9;
|
||||
return true;
|
||||
case 9:
|
||||
_i2 = -1;
|
||||
return false;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000115 RID: 277 RVA: 0x00005BA8 File Offset: 0x00003DA8
|
||||
int I1<int>.I1M()
|
||||
{
|
||||
return _i3;
|
||||
}
|
||||
|
||||
// Token: 0x06000116 RID: 278 RVA: 0x00005BB0 File Offset: 0x00003DB0
|
||||
void I4.M3()
|
||||
{
|
||||
throw new NotSupportedException();
|
||||
}
|
||||
|
||||
// Token: 0x06000117 RID: 279 RVA: 0x00005BB8 File Offset: 0x00003DB8
|
||||
object I4.M2()
|
||||
{
|
||||
return _i3;
|
||||
}
|
||||
|
||||
// Token: 0x06000118 RID: 280 RVA: 0x00005BC8 File Offset: 0x00003DC8
|
||||
I1<int> I2<int>.I2M()
|
||||
{
|
||||
C ret;
|
||||
if (_i2 == -2 && _i5 == Thread.CurrentThread.ManagedThreadId)
|
||||
{
|
||||
_i2 = 0;
|
||||
ret = this;
|
||||
}
|
||||
else
|
||||
{
|
||||
ret = new C(0);
|
||||
}
|
||||
ret._i8 = I6;
|
||||
return ret;
|
||||
}
|
||||
|
||||
// Token: 0x06000119 RID: 281 RVA: 0x00005C10 File Offset: 0x00003E10
|
||||
I4 I3.M1()
|
||||
{
|
||||
return ((I2<int>)this).I2M();
|
||||
}
|
||||
|
||||
// Token: 0x0400003D RID: 61
|
||||
private int _i2; // \u0002
|
||||
|
||||
// Token: 0x0400003E RID: 62
|
||||
private int _i3; // \u0003
|
||||
|
||||
// Token: 0x0400003F RID: 63
|
||||
private readonly int _i5; // \u0005
|
||||
|
||||
// Token: 0x04000040 RID: 64
|
||||
private int _i8; // \u0008
|
||||
|
||||
// Token: 0x04000041 RID: 65
|
||||
public int I6; // \u0006
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,26 @@
|
||||
using System;
|
||||
|
||||
namespace UnitTestProject.RefVm
|
||||
{
|
||||
// Token: 0x02000009 RID: 9
|
||||
static class SimpleTypeHelper // \u0002\u2006
|
||||
{
|
||||
// Token: 0x06000033 RID: 51 RVA: 0x000027AC File Offset: 0x000009AC
|
||||
public static bool IsNullableGeneric(Type t) // \u0002
|
||||
{
|
||||
return t.IsGenericType && t.GetGenericTypeDefinition() == NullableType; // \u0003
|
||||
}
|
||||
|
||||
// Token: 0x04000008 RID: 8
|
||||
public static readonly Type ObjectType = typeof(object); // \u0002
|
||||
|
||||
// Token: 0x04000009 RID: 9
|
||||
private static readonly Type NullableType = typeof(Nullable<>); // \u0003
|
||||
|
||||
// Token: 0x0400000A RID: 10
|
||||
public static readonly Type TypedReferenceType = typeof(TypedReference); // \u0005
|
||||
|
||||
// Token: 0x0400000B RID: 11
|
||||
public static readonly Type EnumType = typeof(Enum); // \u0008
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,648 @@
|
||||
using System;
|
||||
using System.Diagnostics;
|
||||
using System.IO;
|
||||
using System.Reflection;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
using forms_cil;
|
||||
|
||||
// Token: 0x0200003D RID: 61
|
||||
namespace UnitTestProject.RefVm
|
||||
{
|
||||
public static class StringDecryptor // \u0006\u2009
|
||||
{
|
||||
private static BinStreamReader _binStreamReader; // \u0003
|
||||
private static readonly DecryptedStrings DecryptedStringsGlobal; // \u0002
|
||||
private static byte[] _commonKey; // \u0005
|
||||
private static short _keyLength; // \u0008
|
||||
private static readonly Enum1 Enum1Dummy; // \u0003\u2000
|
||||
private static int _int1Dummy; // \u0002\u2000
|
||||
private static int _int2Dummy; // \u000F
|
||||
private static int _int3Dummy; // \u0006
|
||||
private static byte[] _pkt; // \u000E
|
||||
|
||||
// Token: 0x060002CE RID: 718 RVA: 0x00013060 File Offset: 0x00011260
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
static StringDecryptor()
|
||||
{
|
||||
var num = -42518532;
|
||||
var num2 = num ^ 1885636661;
|
||||
DecryptedStringsGlobal = new DecryptedStrings(1970604170 + num + num2 /*9*/);
|
||||
|
||||
var num3 = 2;
|
||||
var stackTrace = new StackTrace(num3, false);
|
||||
num3 -= 2;
|
||||
var frame = stackTrace.GetFrame(num3);
|
||||
var index = num3;
|
||||
if (frame == null)
|
||||
{
|
||||
stackTrace = new StackTrace();
|
||||
index = 1;
|
||||
frame = stackTrace.GetFrame(index);
|
||||
}
|
||||
var num4 = ~- -~~-~-~(1341405001 ^ num ^ num2) ^ -~~- -~-~~(2095196650 + num - num2);
|
||||
var methodBase = frame?.GetMethod();
|
||||
if (frame != null)
|
||||
{
|
||||
num4 ^= ~- -~~-~-~(num ^ -1658751032 ^ num2);
|
||||
}
|
||||
var type = methodBase?.DeclaringType;
|
||||
if (type == typeof(RuntimeMethodHandle))
|
||||
{
|
||||
Enum1Dummy = (Enum1)(4 | (int)Enum1Dummy);
|
||||
num4 ^= 1970604898 + num + num2 + num3;
|
||||
}
|
||||
else if (type == null)
|
||||
{
|
||||
if (CheckStack(stackTrace, index))
|
||||
{
|
||||
num4 ^= ~-~- -~~-~(-1970628130 - num - num2) - num3;
|
||||
Enum1Dummy = (Enum1)(16 | (int)Enum1Dummy);
|
||||
}
|
||||
else
|
||||
{
|
||||
num4 ^= ~- -~~-~-~(num ^ -1885608078 ^ num2);
|
||||
Enum1Dummy = (Enum1)(1 | (int)Enum1Dummy);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
num4 ^= ~-~- -~~-~(1885542988 - num + num2) - num3;
|
||||
Enum1Dummy = (Enum1)(16 | (int)Enum1Dummy);
|
||||
}
|
||||
_int1Dummy += num4;
|
||||
}
|
||||
|
||||
// Token: 0x060002CF RID: 719 RVA: 0x000131D4 File Offset: 0x000113D4
|
||||
public static string GetString(int id) // \u0002
|
||||
{
|
||||
lock (DecryptedStringsGlobal)
|
||||
{
|
||||
return DecryptedStringsGlobal[id] ?? DecryptString(id, true);
|
||||
}
|
||||
}
|
||||
public static void SetString(int id, string val) // for unit tests
|
||||
{
|
||||
lock (DecryptedStringsGlobal)
|
||||
{
|
||||
DecryptedStringsGlobal[id] = val;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060002D0 RID: 720 RVA: 0x00013224 File Offset: 0x00011424
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
private static string DecryptString(int id, bool dummy) // \u0002
|
||||
{
|
||||
var num = 1500675437;
|
||||
var num2 = 1065028357 - num;
|
||||
byte[] key;
|
||||
string str;
|
||||
int num6;
|
||||
if (_binStreamReader == null)
|
||||
{
|
||||
var executingAssembly = Assembly.GetExecutingAssembly();
|
||||
_int3Dummy |= num ^ -1084071305 ^ num2;
|
||||
var stringBuilder = new StringBuilder();
|
||||
var num3 = -1821765671 - num + num2;
|
||||
stringBuilder.Append((char)(num3 >> 16)).Append((char)num3);
|
||||
num3 = 1822175277 + num ^ num2;
|
||||
stringBuilder.Append((char)(num3 >> 16)).Append((char)num3);
|
||||
num3 = (1619914499 ^ num) + num2;
|
||||
stringBuilder.Append((char)num3).Append((char)(num3 >> 16));
|
||||
num3 = 1602104074 - num - num2;
|
||||
stringBuilder.Append((char)num3).Append((char)(num3 >> 16));
|
||||
num3 = (num ^ 1619980037) + num2;
|
||||
stringBuilder.Append((char)num3).Append((char)(num3 >> 16));
|
||||
num3 = num + -1398984659 - num2;
|
||||
stringBuilder.Append((char)num3).Append((char)(num3 >> 16));
|
||||
var manifestResourceStream = executingAssembly.GetManifestResourceStream(/* added by ursoft */ "forms_cil." +
|
||||
stringBuilder.ToString()
|
||||
/* added by ursoft */.GetHashCode().ToString());
|
||||
var num4 = 2;
|
||||
var stackTrace = new StackTrace(num4, false);
|
||||
_int3Dummy ^= (1082521283 ^ num) + num2 | num4;
|
||||
num4 -= 2;
|
||||
var frame = stackTrace.GetFrame(num4);
|
||||
var index = num4;
|
||||
if (frame == null)
|
||||
{
|
||||
stackTrace = new StackTrace();
|
||||
index = 1;
|
||||
frame = stackTrace.GetFrame(index);
|
||||
}
|
||||
var methodBase = frame?.GetMethod();
|
||||
_int3Dummy ^= num4 + (num + -1936322645 ^ num2);
|
||||
var type = methodBase?.DeclaringType;
|
||||
if (frame == null)
|
||||
{
|
||||
_int3Dummy ^= 1065247672 - num - num2;
|
||||
}
|
||||
var flag = type == typeof(RuntimeMethodHandle);
|
||||
_int3Dummy ^= (num ^ 1082461797) + num2;
|
||||
if (!flag)
|
||||
{
|
||||
flag = type == null;
|
||||
if (flag)
|
||||
{
|
||||
if (CheckStack(stackTrace, index))
|
||||
{
|
||||
flag = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
_int3Dummy ^= 1065247640 - num - num2;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (flag)
|
||||
{
|
||||
_int3Dummy ^= 32;
|
||||
}
|
||||
_int3Dummy ^= (num ^ 1082521251) + num2 | num4 + 1;
|
||||
_binStreamReader = new BinStreamReader(manifestResourceStream);
|
||||
var commonKeyLength = (short)(_binStreamReader.ReadHeaderInt16() ^ ~(short)-(short)-(short)~(short)~(short)-(short)~(short)-(short)~(short)-(short)~(short)(-1065050389 + num ^ num2));
|
||||
if (commonKeyLength == 0)
|
||||
{
|
||||
_keyLength = (short)(_binStreamReader.ReadHeaderInt16() ^ -(short)~(short)~(short)-(short)-(short)~(short)~(short)-(short)-(short)~(short)~(short)((-1082482306 ^ num) - num2));
|
||||
}
|
||||
else
|
||||
{
|
||||
_commonKey = _binStreamReader.Read(commonKeyLength);
|
||||
}
|
||||
var assembly = executingAssembly;
|
||||
var assemblyName = SafeAssemblyName(assembly);
|
||||
_pkt = SafeAssemblyPkt(assemblyName);
|
||||
num6 = _int1Dummy;
|
||||
_int1Dummy = 0;
|
||||
var num7 = SdMetadataTokens.GetLong();
|
||||
num6 ^= (int)(uint)num7;
|
||||
num6 ^= -888987382 - num + num2;
|
||||
var num8 = num6;
|
||||
var num9 = num8;
|
||||
var num10 = 0;
|
||||
var num11 = num9 ^ -1693408934 + num - num2;
|
||||
var num12 = num11 * (1936327810 - num + num2) % ((num ^ -1092770072) - num2);
|
||||
var num13 = num12;
|
||||
var obj = ((I2<int>)new SdTemplateStuff.C(-1065028359 + num | num2)
|
||||
{
|
||||
I6 = num13
|
||||
}).I2M();
|
||||
try
|
||||
{
|
||||
while (obj.I4M())
|
||||
{
|
||||
var num14 = obj.I1M();
|
||||
num12 ^= num10 - num14 << 2;
|
||||
num10 += num12 >> 3;
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
obj?.I5M();
|
||||
}
|
||||
num6 ^= ~- -~-~~- -~~(num ^ 1140387705 ^ num2);
|
||||
var num15 = num12;
|
||||
num6 = num15 + num6;
|
||||
_int2Dummy = num6;
|
||||
_int3Dummy = (_int3Dummy & -1667887203 + num - num2) ^ (num ^ 1082519937) + num2;
|
||||
if ((Enum1Dummy & (Enum1)(-~~- -~-~~(1936322518 - num ^ num2))) == 0)
|
||||
{
|
||||
_int3Dummy = (-1082440641 ^ num) - num2;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
num6 = _int2Dummy;
|
||||
}
|
||||
if (_int3Dummy == 1936366479 - num + num2)
|
||||
{
|
||||
return new string(new[] { (char)((-1082462051 ^ num) - num2), '0', (char)(num + -1065028269 + num2) });
|
||||
}
|
||||
var num16 = id ^ -1010833342 ^ num ^ num2 ^ num6;
|
||||
num16 ^= -1459130838 - num + num2;
|
||||
_binStreamReader.GetStream().Position = num16;
|
||||
if (_commonKey != null)
|
||||
{
|
||||
key = _commonKey;
|
||||
}
|
||||
else
|
||||
{
|
||||
short keyLength;
|
||||
if (_keyLength == -1)
|
||||
{
|
||||
keyLength = (short)(_binStreamReader.ReadHeaderInt32() ^ num + -1936293566 - num2 ^ num16);
|
||||
}
|
||||
else
|
||||
{
|
||||
keyLength = _keyLength;
|
||||
}
|
||||
if (keyLength == 0)
|
||||
{
|
||||
key = null;
|
||||
}
|
||||
else
|
||||
{
|
||||
key = _binStreamReader.Read(keyLength);
|
||||
for (var i = 0; i != key.Length; i = 1 + i)
|
||||
{
|
||||
key[i] ^= (byte)(_int2Dummy >> ((3 & i) << 3));
|
||||
}
|
||||
}
|
||||
}
|
||||
var stringHeader = _binStreamReader.ReadHeaderInt32() ^ num16 ^ -~~-~-~-~((num ^ -1882046960) + num2) ^ num6;
|
||||
if (stringHeader != (1936322515 - num | num2))
|
||||
{
|
||||
var flagAnsi = (stringHeader & 211161131 + num - num2) != 0;
|
||||
var flagCompressed = (stringHeader & (-8713467 - num ^ num2)) != 0;
|
||||
var flagSecure = (stringHeader & (1619332869 ^ num) + num2) != 0;
|
||||
stringHeader &= num + -1870334726 ^ num2;
|
||||
var packedStringBuf = _binStreamReader.Read(stringHeader);
|
||||
// ReSharper disable once PossibleNullReferenceException
|
||||
var key1 = key[1];
|
||||
var length = packedStringBuf.Length;
|
||||
var key1XorLen = (byte)(11 + length ^ 7 + key1);
|
||||
var keysXorLen = (uint)((key[0] | key[2] << 8) + (key1XorLen << 3));
|
||||
ushort keysXorLenLowWord = 0;
|
||||
for (var index = 0; index < length; ++index)
|
||||
{
|
||||
if ((index & 1) == 0)
|
||||
{
|
||||
keysXorLen = keysXorLen * (uint)((num ^ -1082544904) - num2) + (uint)(num + -1933863442 ^ num2);
|
||||
keysXorLenLowWord = (ushort)(keysXorLen >> 16);
|
||||
}
|
||||
var keysXorLenLowByte = (byte)keysXorLenLowWord;
|
||||
keysXorLenLowWord = (ushort)(keysXorLenLowWord >> 8);
|
||||
var inByte = packedStringBuf[index];
|
||||
packedStringBuf[index] = (byte)(inByte ^ key1 ^ 3 + key1XorLen ^ keysXorLenLowByte);
|
||||
key1XorLen = inByte;
|
||||
}
|
||||
if (_pkt != null != (_int3Dummy != (-1085052045 ^ num) - num2))
|
||||
{
|
||||
for (var j = 0; j < stringHeader; j = 1 + j)
|
||||
{
|
||||
// ReSharper disable once PossibleNullReferenceException
|
||||
var b5 = _pkt[7 & j];
|
||||
b5 = (byte)(b5 << 3 | b5 >> 5);
|
||||
packedStringBuf[j] ^= b5;
|
||||
}
|
||||
}
|
||||
var num23 = _int3Dummy - 12;
|
||||
int unpackedLength;
|
||||
byte[] unpackedStringBuf;
|
||||
if (!flagCompressed)
|
||||
{
|
||||
unpackedLength = stringHeader;
|
||||
unpackedStringBuf = packedStringBuf;
|
||||
}
|
||||
else
|
||||
{
|
||||
unpackedLength = packedStringBuf[2] | packedStringBuf[0] << 16 | packedStringBuf[3] << 8 | packedStringBuf[1] << 24;
|
||||
unpackedStringBuf = new byte[unpackedLength];
|
||||
Unpack(packedStringBuf, 4, unpackedStringBuf);
|
||||
}
|
||||
if (flagAnsi && num23 == (num + -1935832971 ^ num2))
|
||||
{
|
||||
var chArray = new char[unpackedLength];
|
||||
for (var k = 0; k < unpackedLength; k++)
|
||||
{
|
||||
chArray[k] = (char)unpackedStringBuf[k];
|
||||
}
|
||||
str = new string(chArray);
|
||||
}
|
||||
else
|
||||
{
|
||||
str = Encoding.Unicode.GetString(unpackedStringBuf, 0, unpackedStringBuf.Length);
|
||||
}
|
||||
num23 += (-1082461318 ^ num) - num2 + (3 & num23) << 5;
|
||||
if (num23 != (1065521775 - num ^ num2))
|
||||
{
|
||||
var num25 = stringHeader + id ^ -1935385949 + num - num2 ^ (num23 & (-1082460680 ^ num ^ num2));
|
||||
var stringBuilder = new StringBuilder();
|
||||
var num3 = 1065028445 - num - num2;
|
||||
stringBuilder.Append((char)(byte)num3);
|
||||
str = num25.ToString(stringBuilder.ToString());
|
||||
}
|
||||
if (!flagSecure & dummy)
|
||||
{
|
||||
str = string.Intern(str);
|
||||
DecryptedStringsGlobal[id] = str;
|
||||
if (DecryptedStringsGlobal.GetCachedPairs() == (num + -1936322454 ^ num2))
|
||||
{
|
||||
_binStreamReader.Close();
|
||||
_binStreamReader = null;
|
||||
_commonKey = null;
|
||||
_pkt = null;
|
||||
}
|
||||
}
|
||||
return str;
|
||||
}
|
||||
var refId = _binStreamReader.Read(4);
|
||||
id = -64102883 ^ num ^ num2 ^ num6;
|
||||
id = (refId[2] | refId[3] << 16 | refId[0] << 8 | refId[1] << 24) ^ -id;
|
||||
str = DecryptedStringsGlobal[id];
|
||||
return str;
|
||||
}
|
||||
|
||||
// Token: 0x060002D1 RID: 721 RVA: 0x00013A28 File Offset: 0x00011C28
|
||||
private static AssemblyName SafeAssemblyName(Assembly a) // \u0002
|
||||
{
|
||||
AssemblyName result;
|
||||
try
|
||||
{
|
||||
result = a.GetName();
|
||||
}
|
||||
catch
|
||||
{
|
||||
result = new AssemblyName(a.FullName);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// Token: 0x060002D2 RID: 722 RVA: 0x00013A60 File Offset: 0x00011C60
|
||||
private static byte[] SafeAssemblyPkt(AssemblyName an) // \u0002
|
||||
{
|
||||
var array = an.GetPublicKeyToken();
|
||||
if (array != null && array.Length == 0)
|
||||
{
|
||||
array = null;
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
// Token: 0x060002D3 RID: 723 RVA: 0x00013A80 File Offset: 0x00011C80
|
||||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||||
private static bool CheckStack(StackTrace st, int idx) // \u0002
|
||||
{
|
||||
var a = st.GetFrame(idx + 1)?.GetMethod()?.DeclaringType?.Assembly;
|
||||
if (a != null)
|
||||
{
|
||||
var assemblyName = SafeAssemblyName(a);
|
||||
var array = SafeAssemblyPkt(assemblyName);
|
||||
if (array != null && array.Length == 8 && array[0] == 183 && array[7] == 137)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Token: 0x060002D4 RID: 724 RVA: 0x00013AF0 File Offset: 0x00011CF0
|
||||
private static void Unpack(byte[] packedStringBuf, int idxPacked, byte[] unpackedStringBuf) // \u0002
|
||||
{
|
||||
var idxUnpacked = 0;
|
||||
var packedBlockHeader = 0;
|
||||
var byteMask = 0x80;
|
||||
var unpackLen = unpackedStringBuf.Length;
|
||||
while (idxUnpacked < unpackLen)
|
||||
{
|
||||
byteMask <<= 1;
|
||||
if (byteMask == 0x100)
|
||||
{
|
||||
byteMask = 1;
|
||||
packedBlockHeader = packedStringBuf[idxPacked++];
|
||||
}
|
||||
if ((packedBlockHeader & byteMask) == 0)
|
||||
{
|
||||
unpackedStringBuf[idxUnpacked++] = packedStringBuf[idxPacked++];
|
||||
continue;
|
||||
}
|
||||
var knownWordLen = (packedStringBuf[idxPacked] >> 2) + 3;
|
||||
var knownWordOffset = ((packedStringBuf[idxPacked] << 8) | packedStringBuf[idxPacked + 1]) & 0x3ff;
|
||||
idxPacked += 2;
|
||||
var knownWordIdx = idxUnpacked - knownWordOffset;
|
||||
if (knownWordIdx < 0)
|
||||
return;
|
||||
while (--knownWordLen >= 0 && idxUnpacked < unpackLen)
|
||||
{
|
||||
unpackedStringBuf[idxUnpacked++] = unpackedStringBuf[knownWordIdx++];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x0200003E RID: 62
|
||||
internal sealed class BinStreamReader // \u0003\u2002\u200A\u2008\u2008\u200B\u2002\u2006\u2002\u2009\u2009\u2006\u2004\u2006\u2002\u2007\u2006\u2003\u2001\u2007\u2003\u200A\u2009\u200B\u2003\u2001
|
||||
{
|
||||
private byte[] _header; // \u0003
|
||||
private Stream _stream; // \u0002
|
||||
|
||||
// Token: 0x060002D5 RID: 725 RVA: 0x00013B94 File Offset: 0x00011D94
|
||||
public BinStreamReader(Stream stream)
|
||||
{
|
||||
_stream = stream;
|
||||
_header = new byte[4];
|
||||
}
|
||||
|
||||
// Token: 0x060002D6 RID: 726 RVA: 0x00013BB0 File Offset: 0x00011DB0
|
||||
public Stream GetStream() // \u0002
|
||||
{
|
||||
return _stream;
|
||||
}
|
||||
|
||||
// Token: 0x060002D7 RID: 727 RVA: 0x00013BB8 File Offset: 0x00011DB8
|
||||
public short ReadHeaderInt16() // \u0002
|
||||
{
|
||||
ReadHeader(2);
|
||||
return (short) (_header[0] | (_header[1] << 8));
|
||||
}
|
||||
|
||||
// Token: 0x060002D8 RID: 728 RVA: 0x00013BD8 File Offset: 0x00011DD8
|
||||
public int ReadHeaderInt32() // \u0002
|
||||
{
|
||||
ReadHeader(4);
|
||||
return _header[0] | (_header[1] << 8) | (_header[2] << 0x10) | (_header[3] << 0x18);
|
||||
}
|
||||
|
||||
// Token: 0x060002D9 RID: 729 RVA: 0x00013C0C File Offset: 0x00011E0C
|
||||
private void ThrowEOS() // \u0002
|
||||
{
|
||||
throw new EndOfStreamException();
|
||||
}
|
||||
|
||||
// Token: 0x060002DA RID: 730 RVA: 0x00013C14 File Offset: 0x00011E14
|
||||
private void ReadHeader(int headerSize) // \u0002
|
||||
{
|
||||
var offset = 0;
|
||||
int read;
|
||||
if (headerSize == 1)
|
||||
{
|
||||
read = _stream.ReadByte();
|
||||
if (read == -1)
|
||||
ThrowEOS();
|
||||
_header[0] = (byte) read;
|
||||
}
|
||||
else
|
||||
{
|
||||
do
|
||||
{
|
||||
read = _stream.Read(_header, offset, headerSize - offset);
|
||||
if (read == 0)
|
||||
ThrowEOS();
|
||||
offset += read;
|
||||
} while (offset < headerSize);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060002DB RID: 731 RVA: 0x00013C74 File Offset: 0x00011E74
|
||||
public void Close() // \u0003
|
||||
{
|
||||
var stream = _stream;
|
||||
_stream = null;
|
||||
stream?.Close();
|
||||
_header = null;
|
||||
}
|
||||
|
||||
// Token: 0x060002DC RID: 732 RVA: 0x00013CA0 File Offset: 0x00011EA0
|
||||
public byte[] Read(int bytesCount) // \u0002
|
||||
{
|
||||
if (bytesCount < 0)
|
||||
throw new ArgumentOutOfRangeException();
|
||||
var buffer = new byte[bytesCount];
|
||||
var offset = 0;
|
||||
do
|
||||
{
|
||||
var read = _stream.Read(buffer, offset, bytesCount);
|
||||
if (read == 0)
|
||||
break;
|
||||
offset += read;
|
||||
bytesCount -= read;
|
||||
} while (bytesCount > 0);
|
||||
if (offset != buffer.Length)
|
||||
{
|
||||
var dst = new byte[offset];
|
||||
Buffer.BlockCopy(buffer, 0, dst, 0, offset);
|
||||
buffer = dst;
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x0200003F RID: 63
|
||||
internal sealed class DecryptedStrings // \u0005\u2001\u2007\u200B\u2000\u2008\u2008\u2000\u2000\u2006\u2004\u2008\u200B\u2002\u2006\u200B\u2001\u200B\u2003\u2004\u2001\u2004
|
||||
{
|
||||
private int _cachedPairs; // \u0003
|
||||
private Pair[] _arr; // \u0002
|
||||
|
||||
// Token: 0x060002DD RID: 733 RVA: 0x00013CFC File Offset: 0x00011EFC
|
||||
public DecryptedStrings()
|
||||
{
|
||||
_arr = new Pair[0x10];
|
||||
}
|
||||
|
||||
// Token: 0x060002DE RID: 734 RVA: 0x00013D14 File Offset: 0x00011F14
|
||||
public DecryptedStrings(int capacityHint)
|
||||
{
|
||||
var capacity = 0x10;
|
||||
capacityHint = capacityHint << 1;
|
||||
while ((capacity < capacityHint) && (capacity > 0))
|
||||
{
|
||||
capacity = capacity << 1;
|
||||
}
|
||||
if (capacity < 0)
|
||||
{
|
||||
capacity = 0x10;
|
||||
}
|
||||
_arr = new Pair[capacity];
|
||||
}
|
||||
|
||||
// Token: 0x060002DF RID: 735 RVA: 0x00013D54 File Offset: 0x00011F54
|
||||
public int GetCachedPairs()
|
||||
{
|
||||
return _cachedPairs;
|
||||
}
|
||||
|
||||
// Token: 0x060002E0 RID: 736 RVA: 0x00013D5C File Offset: 0x00011F5C
|
||||
private void GrowCache() // \u0002
|
||||
{
|
||||
var length = _arr.Length;
|
||||
var newLength = length * 2;
|
||||
if (newLength > 0)
|
||||
{
|
||||
var newArr = new Pair[newLength];
|
||||
var cnt = 0;
|
||||
for (var i = 0; i < length; i++)
|
||||
{
|
||||
if (_arr[i].val != null)
|
||||
{
|
||||
var index = _arr[i].id & (newLength - 1);
|
||||
while (true)
|
||||
{
|
||||
if (newArr[index].val == null)
|
||||
{
|
||||
newArr[index].val = _arr[i].val;
|
||||
newArr[index].id = _arr[i].id;
|
||||
cnt++;
|
||||
break;
|
||||
}
|
||||
index++;
|
||||
if (index >= newLength)
|
||||
index = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
_arr = newArr;
|
||||
_cachedPairs = cnt;
|
||||
}
|
||||
}
|
||||
|
||||
public string this[int id]
|
||||
{
|
||||
// Token: 0x060002E1 RID: 737 RVA: 0x00013E10 File Offset: 0x00012010
|
||||
get // \u0002
|
||||
{
|
||||
var length = _arr.Length;
|
||||
var index = id & (length - 1);
|
||||
do
|
||||
{
|
||||
if (_arr[index].id == id || _arr[index].val == null)
|
||||
return _arr[index].val;
|
||||
index++;
|
||||
if (index >= length)
|
||||
index = 0;
|
||||
} while (true);
|
||||
}
|
||||
// Token: 0x060002E2 RID: 738 RVA: 0x00013E6C File Offset: 0x0001206C
|
||||
set // \u0002
|
||||
{
|
||||
var length = _arr.Length;
|
||||
var halfLength = length >> 1;
|
||||
var index = id & (length - 1);
|
||||
do
|
||||
{
|
||||
var emptySlot = _arr[index].val == null;
|
||||
if (_arr[index].id == id || emptySlot)
|
||||
{
|
||||
_arr[index].val = value;
|
||||
if (emptySlot)
|
||||
{
|
||||
_arr[index].id = id;
|
||||
_cachedPairs++;
|
||||
if (_cachedPairs > halfLength)
|
||||
GrowCache();
|
||||
}
|
||||
break;
|
||||
}
|
||||
index++;
|
||||
if (index >= length)
|
||||
index = 0;
|
||||
} while (true);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x02000040 RID: 64
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
private struct Pair // \u0002
|
||||
{
|
||||
public int id;
|
||||
public string val;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x02000041 RID: 65
|
||||
[Flags]
|
||||
internal enum Enum1
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,54 @@
|
||||
using System;
|
||||
|
||||
namespace UnitTestProject.RefVm
|
||||
{
|
||||
// Token: 0x02000055 RID: 85
|
||||
internal static class TypeCompatibility // \u000E\u2006
|
||||
{
|
||||
// Token: 0x06000341 RID: 833 RVA: 0x000152D4 File Offset: 0x000134D4
|
||||
public static bool Check(Type t1, Type t2) // t1
|
||||
{
|
||||
if (t1 == t2)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
if (t1 == null || t2 == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (t1.IsByRef)
|
||||
{
|
||||
return t2.IsByRef && Check(t1.GetElementType(), t2.GetElementType());
|
||||
}
|
||||
if (t2.IsByRef)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (t1.IsPointer)
|
||||
{
|
||||
return t2.IsPointer && Check(t1.GetElementType(), t2.GetElementType());
|
||||
}
|
||||
if (t2.IsPointer)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (t1.IsArray)
|
||||
{
|
||||
return t2.IsArray && t1.GetArrayRank() == t2.GetArrayRank() && Check(t1.GetElementType(), t2.GetElementType());
|
||||
}
|
||||
if (t2.IsArray)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (t1.IsGenericType && !t1.IsGenericTypeDefinition)
|
||||
{
|
||||
t1 = t1.GetGenericTypeDefinition();
|
||||
}
|
||||
if (t2.IsGenericType && !t2.IsGenericTypeDefinition)
|
||||
{
|
||||
t2 = t2.GetGenericTypeDefinition();
|
||||
}
|
||||
return t1 == t2;
|
||||
}
|
||||
}
|
||||
}
|
||||
2621
runtime/VMProtect.Runtime/Tests/UnitTestProject/RefVm/VariantBase.cs
Normal file
2621
runtime/VMProtect.Runtime/Tests/UnitTestProject/RefVm/VariantBase.cs
Normal file
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,165 @@
|
||||
using System;
|
||||
using System.Runtime.Serialization;
|
||||
|
||||
namespace UnitTestProject.RefVm
|
||||
{
|
||||
// Token: 0x02000045 RID: 69
|
||||
internal static class VariantFactory // \u0008\u2002
|
||||
{
|
||||
// Token: 0x060002F6 RID: 758 RVA: 0x000144E0 File Offset: 0x000126E0
|
||||
private static bool IsDerivedFrom<T>(Type obj) // \u0002
|
||||
{
|
||||
var typeFromHandle = typeof(T);
|
||||
return obj == typeFromHandle || obj.IsSubclassOf(typeFromHandle);
|
||||
}
|
||||
|
||||
// Token: 0x060002F7 RID: 759 RVA: 0x00014508 File Offset: 0x00012708
|
||||
public static VariantBase Convert(object src, Type t) // \u0002
|
||||
{
|
||||
var ret = src as VariantBase;
|
||||
if (ret != null)
|
||||
{
|
||||
return ret;
|
||||
}
|
||||
if (t == null)
|
||||
{
|
||||
if (src == null)
|
||||
{
|
||||
return new ObjectVariant();
|
||||
}
|
||||
t = src.GetType();
|
||||
}
|
||||
t = ElementedTypeHelper.TryGoToPointerOrReferenceElementType(t);
|
||||
if (t == SimpleTypeHelper.ObjectType)
|
||||
{
|
||||
ret = new ObjectVariant();
|
||||
if (src != null && src.GetType() != SimpleTypeHelper.ObjectType)
|
||||
{
|
||||
ret.SetVariantType(src.GetType());
|
||||
}
|
||||
}
|
||||
else if (IsDerivedFrom<Array>(t))
|
||||
{
|
||||
ret = new ArrayVariant();
|
||||
}
|
||||
else if (IsDerivedFrom<string>(t))
|
||||
{
|
||||
ret = new StringVariant();
|
||||
}
|
||||
else if (IsDerivedFrom<IntPtr>(t))
|
||||
{
|
||||
ret = new IntPtrVariant();
|
||||
}
|
||||
else if (IsDerivedFrom<UIntPtr>(t))
|
||||
{
|
||||
ret = new UIntPtrVariant();
|
||||
}
|
||||
else if (IsDerivedFrom<ulong>(t))
|
||||
{
|
||||
ret = new UlongVariant();
|
||||
}
|
||||
else if (IsDerivedFrom<uint>(t))
|
||||
{
|
||||
ret = new UintVariant();
|
||||
}
|
||||
else if (IsDerivedFrom<ushort>(t))
|
||||
{
|
||||
ret = new UshortVariant();
|
||||
}
|
||||
else if (IsDerivedFrom<long>(t))
|
||||
{
|
||||
ret = new LongVariant();
|
||||
}
|
||||
else if (IsDerivedFrom<int>(t))
|
||||
{
|
||||
ret = new IntVariant();
|
||||
}
|
||||
else if (IsDerivedFrom<short>(t))
|
||||
{
|
||||
ret = new ShortVariant();
|
||||
}
|
||||
else if (IsDerivedFrom<byte>(t))
|
||||
{
|
||||
ret = new ByteVariant();
|
||||
}
|
||||
else if (IsDerivedFrom<sbyte>(t))
|
||||
{
|
||||
ret = new SbyteVariant();
|
||||
}
|
||||
else if (IsDerivedFrom<double>(t))
|
||||
{
|
||||
ret = new DoubleVariant();
|
||||
}
|
||||
else if (IsDerivedFrom<float>(t))
|
||||
{
|
||||
ret = new FloatVariant();
|
||||
}
|
||||
else if (IsDerivedFrom<bool>(t))
|
||||
{
|
||||
ret = new BoolVariant();
|
||||
}
|
||||
else if (IsDerivedFrom<char>(t))
|
||||
{
|
||||
ret = new CharVariant();
|
||||
}
|
||||
else if (SimpleTypeHelper.IsNullableGeneric(t))
|
||||
{
|
||||
var ov = new ObjectVariant();
|
||||
ov.SetVariantType(t);
|
||||
ret = ov;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (IsDerivedFrom<Enum>(t))
|
||||
{
|
||||
Enum e;
|
||||
if (src == null)
|
||||
{
|
||||
e = (Enum)Activator.CreateInstance(t);
|
||||
}
|
||||
else if (t == SimpleTypeHelper.EnumType && src is Enum)
|
||||
{
|
||||
e = (Enum)src;
|
||||
}
|
||||
else
|
||||
{
|
||||
e = (Enum)Enum.ToObject(t, src);
|
||||
}
|
||||
return new EnumVariant(e);
|
||||
}
|
||||
if (IsDerivedFrom<ValueType>(t))
|
||||
{
|
||||
if (src == null)
|
||||
{
|
||||
var vt = (t == SimpleTypeHelper.TypedReferenceType) ?
|
||||
FormatterServices.GetSafeUninitializedObject(SimpleTypeHelper.TypedReferenceType) :
|
||||
Activator.CreateInstance(t);
|
||||
ret = new ValueTypeVariant(vt);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (src.GetType() != t)
|
||||
{
|
||||
try
|
||||
{
|
||||
src = System.Convert.ChangeType(src, t);
|
||||
}
|
||||
catch
|
||||
{
|
||||
// ignored
|
||||
}
|
||||
}
|
||||
ret = new ValueTypeVariant(src);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
ret = new ObjectVariant();
|
||||
}
|
||||
if (src != null)
|
||||
{
|
||||
ret.SetValueAbstract(src);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
}
|
||||
7505
runtime/VMProtect.Runtime/Tests/UnitTestProject/RefVm/VmExecutor.cs
Normal file
7505
runtime/VMProtect.Runtime/Tests/UnitTestProject/RefVm/VmExecutor.cs
Normal file
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,899 @@
|
||||
using System;
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using System.Diagnostics;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
using System.Reflection;
|
||||
using System.Threading;
|
||||
|
||||
// ReSharper disable UnusedMember.Global
|
||||
|
||||
namespace UnitTestProject.RefVm
|
||||
{
|
||||
// Token: 0x0200002E RID: 46
|
||||
[SuppressMessage("ReSharper", "InconsistentNaming")]
|
||||
public class VmInstrCodesDb // \u0006\u2005
|
||||
{
|
||||
// Token: 0x04000068 RID: 104
|
||||
private VmInstrInfo[] _all;
|
||||
|
||||
// Token: 0x0400011D RID: 285
|
||||
private bool _initialized;
|
||||
|
||||
// Token: 0x0600015B RID: 347 RVA: 0x000075B8 File Offset: 0x000057B8
|
||||
public bool IsInitialized() // \u0002
|
||||
{
|
||||
return _initialized;
|
||||
}
|
||||
|
||||
// Token: 0x0600015C RID: 348 RVA: 0x000075C0 File Offset: 0x000057C0
|
||||
public void SetInitialized(bool val) // \u0002
|
||||
{
|
||||
_initialized = val;
|
||||
}
|
||||
|
||||
// Token: 0x0600015A RID: 346 RVA: 0x000075A8 File Offset: 0x000057A8
|
||||
public IEnumerable<VmInstrInfo> MyFieldsEnumerator() // \u0002
|
||||
{
|
||||
return new FieldsEnumerator(-2)
|
||||
{
|
||||
Source = this
|
||||
};
|
||||
}
|
||||
|
||||
// Token: 0x0600015D RID: 349 RVA: 0x000075CC File Offset: 0x000057CC
|
||||
public VmInstrInfo[] ToSortedArray() // \u0002
|
||||
{
|
||||
if (_all == null)
|
||||
{
|
||||
lock (this)
|
||||
{
|
||||
if (_all == null)
|
||||
{
|
||||
var list = new List<VmInstrInfo>(256);
|
||||
list.AddRange(MyFieldsEnumerator());
|
||||
if (SortHelper.MyComparison == null)
|
||||
{
|
||||
SortHelper.MyComparison = SortHelper.MySortHelper.Compare;
|
||||
}
|
||||
list.Sort(SortHelper.MyComparison);
|
||||
_all = list.ToArray();
|
||||
}
|
||||
}
|
||||
}
|
||||
return _all;
|
||||
}
|
||||
|
||||
// Token: 0x0200002F RID: 47
|
||||
[Serializable]
|
||||
private sealed class SortHelper // \u0002
|
||||
{
|
||||
// Token: 0x06000160 RID: 352 RVA: 0x000076A0 File Offset: 0x000058A0
|
||||
internal int Compare(VmInstrInfo v1, VmInstrInfo v2) // \u0002
|
||||
{
|
||||
return v1.Id.CompareTo(v2.Id);
|
||||
}
|
||||
|
||||
// Token: 0x04000129 RID: 297
|
||||
public static readonly SortHelper MySortHelper = new SortHelper(); // \u0002
|
||||
|
||||
// Token: 0x0400012A RID: 298
|
||||
public static Comparison<VmInstrInfo> MyComparison; // \u0003
|
||||
}
|
||||
|
||||
// Token: 0x02000030 RID: 48
|
||||
private sealed class FieldsEnumerator : IEnumerable<VmInstrInfo>, IEnumerator<VmInstrInfo> // \u0003
|
||||
{
|
||||
// Token: 0x06000161 RID: 353 RVA: 0x000076C4 File Offset: 0x000058C4
|
||||
public FieldsEnumerator(int st)
|
||||
{
|
||||
_state = st;
|
||||
_threadId = Thread.CurrentThread.ManagedThreadId;
|
||||
}
|
||||
|
||||
// Token: 0x06000162 RID: 354 RVA: 0x000076E4 File Offset: 0x000058E4
|
||||
void IDisposable.Dispose() // \u0003\u2008\u2000\u2002\u200A\u0002
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x06000163 RID: 355 RVA: 0x000076E8 File Offset: 0x000058E8
|
||||
bool IEnumerator.MoveNext()
|
||||
{
|
||||
var num = _state;
|
||||
if (num != 0)
|
||||
{
|
||||
if (num != 1)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_state = -1;
|
||||
_index++;
|
||||
}
|
||||
else
|
||||
{
|
||||
_state = -1;
|
||||
var fields = typeof(VmInstrCodesDb).GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public);
|
||||
_data = fields;
|
||||
_index = 0;
|
||||
}
|
||||
if (_index >= _data.Length)
|
||||
{
|
||||
_data = null;
|
||||
return false;
|
||||
}
|
||||
var p = (VmInstrInfo)_data[_index].GetValue(Source);
|
||||
_current = p;
|
||||
_state = 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
// Token: 0x06000164 RID: 356 RVA: 0x00007790 File Offset: 0x00005990
|
||||
VmInstrInfo IEnumerator<VmInstrInfo>.Current // \u0003\u2008\u2000\u2002\u200A\u0002
|
||||
=> _current;
|
||||
|
||||
// Token: 0x06000165 RID: 357 RVA: 0x00007798 File Offset: 0x00005998
|
||||
[DebuggerHidden]
|
||||
void IEnumerator.Reset() // \u0003\u2008\u2000\u2002\u200A\u0003
|
||||
{
|
||||
throw new NotSupportedException();
|
||||
}
|
||||
|
||||
// Token: 0x06000166 RID: 358 RVA: 0x000077A0 File Offset: 0x000059A0
|
||||
[DebuggerHidden]
|
||||
object IEnumerator.Current // \u0003\u2008\u2000\u2002\u200A\u0002
|
||||
=> _current;
|
||||
|
||||
// Token: 0x06000167 RID: 359 RVA: 0x000077A8 File Offset: 0x000059A8
|
||||
[DebuggerHidden]
|
||||
IEnumerator<VmInstrInfo> IEnumerable<VmInstrInfo>.GetEnumerator() // \u0003\u2008\u2000\u2002\u200A\u0002
|
||||
{
|
||||
FieldsEnumerator ret;
|
||||
if (_state == -2 && _threadId == Thread.CurrentThread.ManagedThreadId)
|
||||
{
|
||||
_state = 0;
|
||||
ret = this;
|
||||
}
|
||||
else
|
||||
{
|
||||
ret = new FieldsEnumerator(0) {Source = Source};
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
// Token: 0x06000168 RID: 360 RVA: 0x000077F0 File Offset: 0x000059F0
|
||||
[DebuggerHidden]
|
||||
IEnumerator IEnumerable.GetEnumerator() // \u0003\u2008\u2000\u2002\u200A\u0002
|
||||
{
|
||||
return ((IEnumerable<VmInstrInfo>)this).GetEnumerator();
|
||||
}
|
||||
|
||||
// Token: 0x0400012B RID: 299
|
||||
private int _state; // \u0002
|
||||
|
||||
// Token: 0x0400012C RID: 300
|
||||
private VmInstrInfo _current; // \u0003
|
||||
|
||||
// Token: 0x0400012D RID: 301
|
||||
private readonly int _threadId; // \u0005
|
||||
|
||||
// Token: 0x0400012E RID: 302
|
||||
public VmInstrCodesDb Source; // \u0008
|
||||
|
||||
// Token: 0x0400012F RID: 303
|
||||
private FieldInfo[] _data; // \u0006
|
||||
|
||||
// Token: 0x04000130 RID: 304
|
||||
private int _index; // \u000E
|
||||
}
|
||||
|
||||
#region all
|
||||
/*
|
||||
no. { typecheck, rangecheck, nullcheck } The specified fault check(s) normally performed as part of the execution of the subsequent instruction can/shall be skipped. Prefix to instruction
|
||||
readonly. Specify that the subsequent array address operation performs no type check at runtime, and that it returns a controlled-mutability managed pointer Prefix to instruction
|
||||
tail. Subsequent call terminates current method Prefix to instruction
|
||||
unaligned. (alignment) Subsequent pointer instruction might be unaligned. Prefix to instruction
|
||||
volatile. Subsequent pointer reference is volatile. Prefix to instruction
|
||||
*/
|
||||
// Token: 0x04000063 RID: 99
|
||||
public readonly VmInstrInfo U0002U2000 = new VmInstrInfo(690984147, VmOperandType.Ot11Nope); // not implemented
|
||||
|
||||
// Token: 0x04000077 RID: 119
|
||||
public readonly VmInstrInfo U0006U2001U2000 = new VmInstrInfo(733028785, VmOperandType.Ot11Nope); // not implemented
|
||||
|
||||
// Token: 0x0400007A RID: 122
|
||||
public readonly VmInstrInfo U0006U2001 = new VmInstrInfo(701247957, VmOperandType.Ot11Nope); // not implemented
|
||||
|
||||
// Token: 0x04000086 RID: 134
|
||||
public readonly VmInstrInfo U0006U2004 = new VmInstrInfo(-377358754, VmOperandType.Ot11Nope); // not implemented
|
||||
|
||||
// Token: 0x040000B0 RID: 176
|
||||
public readonly VmInstrInfo U0006U2008U2000 = new VmInstrInfo(1026942272, VmOperandType.Ot11Nope); // empty impl
|
||||
|
||||
// Token: 0x040000B2 RID: 178
|
||||
public readonly VmInstrInfo Endfilter_ = new VmInstrInfo(-1041717787, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000C6 RID: 198
|
||||
public readonly VmInstrInfo Mul_ovf_ = new VmInstrInfo(717697778, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000CB RID: 203
|
||||
public readonly VmInstrInfo Endfinally_ = new VmInstrInfo(-860175516, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000E0 RID: 224
|
||||
public readonly VmInstrInfo U0003U2009 = new VmInstrInfo(-1535884281, VmOperandType.Ot11Nope); // not implemented
|
||||
|
||||
// Token: 0x04000080 RID: 128
|
||||
public readonly VmInstrInfo U000EU2006U2000 = new VmInstrInfo(1756761351, VmOperandType.Ot5Int); // ??? invoke some method
|
||||
|
||||
// Token: 0x04000082 RID: 130
|
||||
public readonly VmInstrInfo Jmp_ = new VmInstrInfo(-512817309, VmOperandType.Ot12Int);
|
||||
|
||||
// Token: 0x040000CC RID: 204
|
||||
public readonly VmInstrInfo Initobj_ = new VmInstrInfo(-647649665, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x04000065 RID: 101
|
||||
public readonly VmInstrInfo Calli_ = new VmInstrInfo(1295283437, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x0400006F RID: 111
|
||||
public readonly VmInstrInfo Constrained_ = new VmInstrInfo(1803463719, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x04000098 RID: 152
|
||||
public readonly VmInstrInfo U000FU2001 = new VmInstrInfo(-1952417400, VmOperandType.Ot5Int); // empty impl
|
||||
|
||||
// Token: 0x040000E1 RID: 225
|
||||
public readonly VmInstrInfo Box_ = new VmInstrInfo(1491096114, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x040000E4 RID: 228
|
||||
public readonly VmInstrInfo U0006U200BU2000 = new VmInstrInfo(-1858492701, VmOperandType.Ot11Nope); // not implemented
|
||||
|
||||
// Token: 0x040000ED RID: 237
|
||||
public readonly VmInstrInfo U0002U2002U2001 = new VmInstrInfo(113196648, VmOperandType.Ot11Nope); // not implemented
|
||||
|
||||
// Token: 0x040000EF RID: 239
|
||||
public readonly VmInstrInfo Ldobj_ = new VmInstrInfo(-564585233, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x04000104 RID: 260
|
||||
public readonly VmInstrInfo Rethrow_ = new VmInstrInfo(989001448, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000125 RID: 293
|
||||
public readonly VmInstrInfo U000EU2000U2000 = new VmInstrInfo(814546329, VmOperandType.Ot11Nope); // not implemented
|
||||
|
||||
// Token: 0x040000B8 RID: 184
|
||||
public readonly VmInstrInfo Newobj_ = new VmInstrInfo(783240206, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x040000B9 RID: 185
|
||||
public readonly VmInstrInfo U0006U2000U2000 = new VmInstrInfo(569679686, VmOperandType.Ot11Nope); // not implemented
|
||||
|
||||
// Token: 0x040000BD RID: 189
|
||||
public readonly VmInstrInfo U0002U200B = new VmInstrInfo(578506051, VmOperandType.Ot6SByte); // leave.s not implemented
|
||||
|
||||
// Token: 0x040000BE RID: 190
|
||||
public readonly VmInstrInfo Leave_ = new VmInstrInfo(182069479, VmOperandType.Ot0UInt);
|
||||
|
||||
// Token: 0x040000B3 RID: 179
|
||||
//public readonly VmInstrInfo U0003U2008 = new VmInstrInfo(56035065, VmOperandType.Nope11);
|
||||
|
||||
// Token: 0x04000052 RID: 82
|
||||
public readonly VmInstrInfo Ldnull_ = new VmInstrInfo(1672432034, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000057 RID: 87
|
||||
public readonly VmInstrInfo Pop_ = new VmInstrInfo(-423590017, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400005B RID: 91
|
||||
public readonly VmInstrInfo Ckfinite_ = new VmInstrInfo(-624596400, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400005D RID: 93
|
||||
public readonly VmInstrInfo Stind_i2_ = new VmInstrInfo(81292670, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400006C RID: 108
|
||||
public readonly VmInstrInfo Stind_r8_ = new VmInstrInfo(-239256528, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000074 RID: 116
|
||||
public readonly VmInstrInfo Ldftn_ = new VmInstrInfo(-204727488, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x04000076 RID: 118
|
||||
public readonly VmInstrInfo Ldlen_ = new VmInstrInfo(-1528794514, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000079 RID: 121
|
||||
public readonly VmInstrInfo Isinst_ = new VmInstrInfo(-1879745689, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x04000081 RID: 129
|
||||
public readonly VmInstrInfo Stind_i8_ = new VmInstrInfo(-279385973, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000087 RID: 135
|
||||
public readonly VmInstrInfo Newarr_ = new VmInstrInfo(1211659810, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x04000089 RID: 137
|
||||
public readonly VmInstrInfo Callvirt_ = new VmInstrInfo(497685394, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x0400008A RID: 138
|
||||
public readonly VmInstrInfo Ldc_i8_ = new VmInstrInfo(598097099, VmOperandType.Ot7Long);
|
||||
|
||||
// Token: 0x0400009A RID: 154
|
||||
public readonly VmInstrInfo Castclass_ = new VmInstrInfo(1816382558, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x0400009C RID: 156
|
||||
public readonly VmInstrInfo Stind_i_ = new VmInstrInfo(-774914583, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400009D RID: 157
|
||||
public readonly VmInstrInfo Ldc_i4_s_ = new VmInstrInfo(1440000960, VmOperandType.Ot6SByte);
|
||||
|
||||
// Token: 0x040000A7 RID: 167
|
||||
public readonly VmInstrInfo Not_ = new VmInstrInfo(2044815068, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000A8 RID: 168
|
||||
public readonly VmInstrInfo Ldtoken_ = new VmInstrInfo(757747961, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x040000AD RID: 173
|
||||
public readonly VmInstrInfo Stind_i4_ = new VmInstrInfo(-587303415, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000B6 RID: 182
|
||||
public readonly VmInstrInfo Ldvirtftn_ = new VmInstrInfo(-1088007919, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x040000BA RID: 186
|
||||
public readonly VmInstrInfo Stind_i1_ = new VmInstrInfo(122987244, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000BC RID: 188
|
||||
public readonly VmInstrInfo Cgt_ = new VmInstrInfo(-290816002, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000C4 RID: 196
|
||||
public readonly VmInstrInfo Stobj_ = new VmInstrInfo(-18831398, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x040000C5 RID: 197
|
||||
public readonly VmInstrInfo Clt_un_ = new VmInstrInfo(-377042092, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000DD RID: 221
|
||||
public readonly VmInstrInfo Cgt_un_ = new VmInstrInfo(-244421767, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000D6 RID: 214
|
||||
public readonly VmInstrInfo Stind_ref_ = new VmInstrInfo(-572078212, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000DF RID: 223
|
||||
public readonly VmInstrInfo Ldloca_ = new VmInstrInfo(-1112986259, VmOperandType.Ot1UShort);
|
||||
|
||||
// Token: 0x040000E9 RID: 233
|
||||
public readonly VmInstrInfo Call_ = new VmInstrInfo(-1118186024, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x040000F9 RID: 249
|
||||
public readonly VmInstrInfo Ldc_r8_ = new VmInstrInfo(-557730397, VmOperandType.Ot4Double);
|
||||
|
||||
// Token: 0x040000FD RID: 253
|
||||
public readonly VmInstrInfo Clt_ = new VmInstrInfo(-1789431058, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000107 RID: 263
|
||||
public readonly VmInstrInfo Ldc_i4_ = new VmInstrInfo(-763377227, VmOperandType.Ot12Int);
|
||||
|
||||
// Token: 0x04000112 RID: 274
|
||||
public readonly VmInstrInfo Ldc_r4_ = new VmInstrInfo(-976252990, VmOperandType.Ot10Float);
|
||||
|
||||
// Token: 0x04000116 RID: 278
|
||||
public readonly VmInstrInfo Stind_r4_ = new VmInstrInfo(2036802079, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000119 RID: 281
|
||||
public readonly VmInstrInfo Nop_ = new VmInstrInfo(-724560934, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400011E RID: 286
|
||||
public readonly VmInstrInfo Ldloca_s_ = new VmInstrInfo(1851592203, VmOperandType.Ot8Byte);
|
||||
|
||||
// Token: 0x04000053 RID: 83
|
||||
public readonly VmInstrInfo Sizeof_ = new VmInstrInfo(-1163259743, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x04000054 RID: 84
|
||||
public readonly VmInstrInfo Ldind_r4_ = new VmInstrInfo(1144322863, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000055 RID: 85
|
||||
public readonly VmInstrInfo Ldelem_i1_ = new VmInstrInfo(322204500, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000056 RID: 86
|
||||
public readonly VmInstrInfo Conv_r8_ = new VmInstrInfo(-195608730, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000058 RID: 88
|
||||
public readonly VmInstrInfo Stelem_i1_ = new VmInstrInfo(-1560659480, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000059 RID: 89
|
||||
public readonly VmInstrInfo Ldstr_ = new VmInstrInfo(-883753595, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x0400005A RID: 90
|
||||
public readonly VmInstrInfo Conv_i4_ = new VmInstrInfo(1738936149, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400005C RID: 92
|
||||
public readonly VmInstrInfo Ldarg_2_ = new VmInstrInfo(917707539, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400005E RID: 94
|
||||
public readonly VmInstrInfo Conv_i1_ = new VmInstrInfo(443736782, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400005F RID: 95
|
||||
public readonly VmInstrInfo Div_ = new VmInstrInfo(873071583, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000060 RID: 96
|
||||
public readonly VmInstrInfo Conv_i_ = new VmInstrInfo(863451657, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000061 RID: 97
|
||||
public readonly VmInstrInfo Stelem_ref_ = new VmInstrInfo(1243606418, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000062 RID: 98
|
||||
public readonly VmInstrInfo Shl_ = new VmInstrInfo(1269228253, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000064 RID: 100
|
||||
public readonly VmInstrInfo Conv_u4_ = new VmInstrInfo(-1046006878, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000066 RID: 102
|
||||
public readonly VmInstrInfo Break_ = new VmInstrInfo(-979485219, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000067 RID: 103
|
||||
public readonly VmInstrInfo Ldc_i4_1_ = new VmInstrInfo(-2108713475, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000069 RID: 105
|
||||
public readonly VmInstrInfo Or_ = new VmInstrInfo(1569462844, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400006A RID: 106
|
||||
public readonly VmInstrInfo Ldelem_ = new VmInstrInfo(-1705118555, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x0400006B RID: 107
|
||||
public readonly VmInstrInfo Conv_u1_ = new VmInstrInfo(1055970854, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400006D RID: 109
|
||||
public readonly VmInstrInfo Ldind_i1_ = new VmInstrInfo(33169414, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400006E RID: 110
|
||||
public readonly VmInstrInfo Ldind_i_ = new VmInstrInfo(-1790442498, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000070 RID: 112
|
||||
public readonly VmInstrInfo Ldsfld_ = new VmInstrInfo(-1369658342, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x04000071 RID: 113
|
||||
public readonly VmInstrInfo Ldloc_ = new VmInstrInfo(766115889, VmOperandType.Ot1UShort);
|
||||
|
||||
// Token: 0x04000072 RID: 114
|
||||
public readonly VmInstrInfo Rem_un_ = new VmInstrInfo(-2121309775, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000073 RID: 115
|
||||
public readonly VmInstrInfo Conv_ovf_i8_ = new VmInstrInfo(-287049786, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000075 RID: 117
|
||||
public readonly VmInstrInfo Ldc_i4_0_ = new VmInstrInfo(89715609, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000078 RID: 120
|
||||
public readonly VmInstrInfo Ldloc_3_ = new VmInstrInfo(1790654656, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400007B RID: 123
|
||||
public readonly VmInstrInfo Ldsflda_ = new VmInstrInfo(-2097007575, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x0400007C RID: 124
|
||||
public readonly VmInstrInfo Add_ovf_ = new VmInstrInfo(-545700640, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400007D RID: 125
|
||||
public readonly VmInstrInfo Refanytype_ = new VmInstrInfo(-971088331, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400007E RID: 126
|
||||
public readonly VmInstrInfo Blt_ = new VmInstrInfo(1978323310, VmOperandType.Ot0UInt);
|
||||
|
||||
// Token: 0x0400007F RID: 127
|
||||
public readonly VmInstrInfo Conv_ovf_u8_un_ = new VmInstrInfo(1527584358, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000083 RID: 131
|
||||
public readonly VmInstrInfo Ldelem_i8_ = new VmInstrInfo(1272142104, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000084 RID: 132
|
||||
public readonly VmInstrInfo Ldc_i4_6_ = new VmInstrInfo(871172961, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000085 RID: 133
|
||||
public readonly VmInstrInfo Starg_s_ = new VmInstrInfo(-687376789, VmOperandType.Ot8Byte);
|
||||
|
||||
// Token: 0x04000088 RID: 136
|
||||
public readonly VmInstrInfo Beq_ = new VmInstrInfo(352236975, VmOperandType.Ot0UInt);
|
||||
|
||||
// Token: 0x0400008B RID: 139
|
||||
public readonly VmInstrInfo Ldfld_ = new VmInstrInfo(-688284774, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x0400008C RID: 140
|
||||
public readonly VmInstrInfo Conv_ovf_i2_un_ = new VmInstrInfo(1663762471, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400008D RID: 141
|
||||
public readonly VmInstrInfo Conv_ovf_i_un_ = new VmInstrInfo(2093357171, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400008E RID: 142
|
||||
public readonly VmInstrInfo Ldelem_u4_ = new VmInstrInfo(896332376, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400008F RID: 143
|
||||
public readonly VmInstrInfo Conv_ovf_u4_un_ = new VmInstrInfo(-107488823, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000090 RID: 144
|
||||
public readonly VmInstrInfo Ldarga_ = new VmInstrInfo(2044160323, VmOperandType.Ot1UShort);
|
||||
|
||||
// Token: 0x04000091 RID: 145
|
||||
public readonly VmInstrInfo Div_un_ = new VmInstrInfo(742839562, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000092 RID: 146
|
||||
public readonly VmInstrInfo Ldelem_r4_ = new VmInstrInfo(-1447311583, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000093 RID: 147
|
||||
public readonly VmInstrInfo And_ = new VmInstrInfo(1968373082, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000094 RID: 148
|
||||
public readonly VmInstrInfo Add_ = new VmInstrInfo(-1892228817, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000095 RID: 149
|
||||
public readonly VmInstrInfo Conv_ovf_u2_ = new VmInstrInfo(1775410326, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000096 RID: 150
|
||||
public readonly VmInstrInfo Xor_ = new VmInstrInfo(-273395395, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000097 RID: 151
|
||||
public readonly VmInstrInfo Stloc_1_ = new VmInstrInfo(-1446892238, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000099 RID: 153
|
||||
public readonly VmInstrInfo Conv_ovf_u2_un_ = new VmInstrInfo(-1274139658, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400009B RID: 155
|
||||
public readonly VmInstrInfo Ldc_i4_3_ = new VmInstrInfo(-722334296, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400009E RID: 158
|
||||
public readonly VmInstrInfo Ldelem_u1_ = new VmInstrInfo(580121148, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400009F RID: 159
|
||||
public readonly VmInstrInfo Ldelem_i4_ = new VmInstrInfo(778369289, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000A0 RID: 160
|
||||
public readonly VmInstrInfo Stfld_ = new VmInstrInfo(1721102239, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x040000A1 RID: 161
|
||||
public readonly VmInstrInfo Ldc_i4_m1_ = new VmInstrInfo(-1374936951, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000A2 RID: 162
|
||||
public readonly VmInstrInfo Brfalse_ = new VmInstrInfo(476056811, VmOperandType.Ot0UInt);
|
||||
|
||||
// Token: 0x040000A3 RID: 163
|
||||
public readonly VmInstrInfo Rem_ = new VmInstrInfo(1127773841, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000A4 RID: 164
|
||||
public readonly VmInstrInfo Neg_ = new VmInstrInfo(1824866698, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000A5 RID: 165
|
||||
public readonly VmInstrInfo Initblk_ = new VmInstrInfo(1848160160, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000A6 RID: 166
|
||||
public readonly VmInstrInfo Ldelem_r8_ = new VmInstrInfo(-522987252, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000A9 RID: 169
|
||||
public readonly VmInstrInfo Cpobj_ = new VmInstrInfo(1238115537, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x040000AA RID: 170
|
||||
public readonly VmInstrInfo Ldarga_s_ = new VmInstrInfo(-1193068213, VmOperandType.Ot8Byte);
|
||||
|
||||
// Token: 0x040000AB RID: 171
|
||||
public readonly VmInstrInfo Br_ = new VmInstrInfo(658728581, VmOperandType.Ot0UInt);
|
||||
|
||||
// Token: 0x040000AC RID: 172
|
||||
public readonly VmInstrInfo Conv_u2_ = new VmInstrInfo(-2099750455, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000AE RID: 174
|
||||
public readonly VmInstrInfo Stelem_i_ = new VmInstrInfo(-358560507, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000AF RID: 175
|
||||
public readonly VmInstrInfo Stloc_s_ = new VmInstrInfo(1804315644, VmOperandType.Ot8Byte);
|
||||
|
||||
// Token: 0x040000B1 RID: 177
|
||||
public readonly VmInstrInfo Ble_un_ = new VmInstrInfo(1001656673, VmOperandType.Ot0UInt);
|
||||
|
||||
// Token: 0x040000B4 RID: 180
|
||||
public readonly VmInstrInfo Ldc_i4_2_ = new VmInstrInfo(-2082446517, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000B5 RID: 181
|
||||
public readonly VmInstrInfo Blt_un_ = new VmInstrInfo(-1002275164, VmOperandType.Ot0UInt);
|
||||
|
||||
// Token: 0x040000B7 RID: 183
|
||||
public readonly VmInstrInfo Ldind_ref_ = new VmInstrInfo(-101579585, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000BB RID: 187
|
||||
public readonly VmInstrInfo Ldind_i2_ = new VmInstrInfo(1338544134, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000BF RID: 191
|
||||
public readonly VmInstrInfo Shr_ = new VmInstrInfo(2061114403, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000C0 RID: 192
|
||||
public readonly VmInstrInfo Sub_ovf_ = new VmInstrInfo(-1326124455, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000C1 RID: 193
|
||||
public readonly VmInstrInfo Mul_ = new VmInstrInfo(-368354161, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000C2 RID: 194
|
||||
public readonly VmInstrInfo Conv_r4_ = new VmInstrInfo(461467744, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000C3 RID: 195
|
||||
public readonly VmInstrInfo Ldarg_s_ = new VmInstrInfo(916919316, VmOperandType.Ot8Byte);
|
||||
|
||||
// Token: 0x040000C7 RID: 199
|
||||
public readonly VmInstrInfo Conv_ovf_u8_ = new VmInstrInfo(-1916788012, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000C8 RID: 200
|
||||
public readonly VmInstrInfo Ldind_u2_ = new VmInstrInfo(-1831891367, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000C9 RID: 201
|
||||
public readonly VmInstrInfo Ldind_u4_ = new VmInstrInfo(-1620795876, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000CA RID: 202
|
||||
public readonly VmInstrInfo Conv_ovf_i4_ = new VmInstrInfo(488024265, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000CD RID: 205
|
||||
public readonly VmInstrInfo Ldarg_1_ = new VmInstrInfo(326597331, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000CE RID: 206
|
||||
public readonly VmInstrInfo Conv_ovf_u_ = new VmInstrInfo(115989675, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000CF RID: 207
|
||||
public readonly VmInstrInfo Ldloc_s_ = new VmInstrInfo(1019004451, VmOperandType.Ot8Byte);
|
||||
|
||||
// Token: 0x040000D0 RID: 208
|
||||
public readonly VmInstrInfo Conv_i2_ = new VmInstrInfo(-108178384, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000D1 RID: 209
|
||||
public readonly VmInstrInfo Conv_ovf_i_ = new VmInstrInfo(-2109763431, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000D2 RID: 210
|
||||
public readonly VmInstrInfo Ble_ = new VmInstrInfo(1321262543, VmOperandType.Ot0UInt);
|
||||
|
||||
// Token: 0x040000D3 RID: 211
|
||||
public readonly VmInstrInfo Unbox_ = new VmInstrInfo(-1668682548, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x040000D4 RID: 212
|
||||
public readonly VmInstrInfo Stelem_r4_ = new VmInstrInfo(-1251429380, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000D5 RID: 213
|
||||
public readonly VmInstrInfo Stloc_3_ = new VmInstrInfo(1073782561, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000D7 RID: 215
|
||||
public readonly VmInstrInfo Brtrue_ = new VmInstrInfo(1985375111, VmOperandType.Ot0UInt);
|
||||
|
||||
// Token: 0x040000D8 RID: 216
|
||||
public readonly VmInstrInfo Stelem_ = new VmInstrInfo(-633052479, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x040000D9 RID: 217
|
||||
public readonly VmInstrInfo Stelem_i4_ = new VmInstrInfo(-638226942, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000DA RID: 218
|
||||
public readonly VmInstrInfo Conv_ovf_u1_un_ = new VmInstrInfo(-854623375, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000DB RID: 219
|
||||
public readonly VmInstrInfo Add_ovf_un_ = new VmInstrInfo(-2145629048, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000DC RID: 220
|
||||
public readonly VmInstrInfo Conv_u8_ = new VmInstrInfo(1396092080, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000DE RID: 222
|
||||
public readonly VmInstrInfo Bgt_ = new VmInstrInfo(-939929863, VmOperandType.Ot0UInt);
|
||||
|
||||
// Token: 0x040000E2 RID: 226
|
||||
public readonly VmInstrInfo Bgt_un_ = new VmInstrInfo(-73779400, VmOperandType.Ot0UInt);
|
||||
|
||||
// Token: 0x040000E3 RID: 227
|
||||
public readonly VmInstrInfo Stelem_r8_ = new VmInstrInfo(849078739, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000E5 RID: 229
|
||||
public readonly VmInstrInfo Mkrefany_ = new VmInstrInfo(1810420701, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x040000E6 RID: 230
|
||||
public readonly VmInstrInfo Conv_ovf_u_un_ = new VmInstrInfo(-1209242284, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000E7 RID: 231
|
||||
public readonly VmInstrInfo Conv_ovf_i1_ = new VmInstrInfo(-1678823314, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000E8 RID: 232
|
||||
public readonly VmInstrInfo Conv_ovf_i1_un_ = new VmInstrInfo(-1171707127, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000EA RID: 234
|
||||
public readonly VmInstrInfo Stsfld_ = new VmInstrInfo(-1272257470, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x040000EB RID: 235
|
||||
public readonly VmInstrInfo Starg_ = new VmInstrInfo(-1559324355, VmOperandType.Ot1UShort);
|
||||
|
||||
// Token: 0x040000EC RID: 236
|
||||
public readonly VmInstrInfo Ldflda_ = new VmInstrInfo(685223722, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x040000EE RID: 238
|
||||
public readonly VmInstrInfo Sub_ = new VmInstrInfo(1925911547, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000F0 RID: 240
|
||||
public readonly VmInstrInfo Conv_ovf_i2_ = new VmInstrInfo(2079826493, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000F1 RID: 241
|
||||
public readonly VmInstrInfo Ldarg_0_ = new VmInstrInfo(-1817778622, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000F2 RID: 242
|
||||
public readonly VmInstrInfo Ldelem_i2_ = new VmInstrInfo(-1703864226, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000F3 RID: 243
|
||||
public readonly VmInstrInfo Ceq_ = new VmInstrInfo(-490385948, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000F4 RID: 244
|
||||
public readonly VmInstrInfo Ldelema_ = new VmInstrInfo(-659575843, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x040000F5 RID: 245
|
||||
public readonly VmInstrInfo Localloc_ = new VmInstrInfo(487454996, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000F6 RID: 246
|
||||
public readonly VmInstrInfo Conv_ovf_i4_un_ = new VmInstrInfo(-900057353, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000F7 RID: 247
|
||||
public readonly VmInstrInfo Bge_un_ = new VmInstrInfo(784647969, VmOperandType.Ot0UInt);
|
||||
|
||||
// Token: 0x040000F8 RID: 248
|
||||
public readonly VmInstrInfo Ldelem_ref_ = new VmInstrInfo(880972378, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000FA RID: 250
|
||||
public readonly VmInstrInfo Conv_ovf_i8_un_ = new VmInstrInfo(20637445, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000FB RID: 251
|
||||
public readonly VmInstrInfo Ldind_i8_ = new VmInstrInfo(-607543449, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000FC RID: 252
|
||||
public readonly VmInstrInfo Refanyval_ = new VmInstrInfo(1010177566, VmOperandType.Ot5Int);
|
||||
|
||||
// Token: 0x040000FE RID: 254
|
||||
public readonly VmInstrInfo Dup_ = new VmInstrInfo(85722172, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x040000FF RID: 255
|
||||
public readonly VmInstrInfo Stloc_0_ = new VmInstrInfo(-1071153572, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000100 RID: 256
|
||||
public readonly VmInstrInfo Ldc_i4_4_ = new VmInstrInfo(-72363801, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000101 RID: 257
|
||||
public readonly VmInstrInfo Ldind_r8_ = new VmInstrInfo(813030660, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000102 RID: 258
|
||||
public readonly VmInstrInfo Ldc_i4_7_ = new VmInstrInfo(-1136876649, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000103 RID: 259
|
||||
public readonly VmInstrInfo Stelem_i8_ = new VmInstrInfo(588832478, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000105 RID: 261
|
||||
public readonly VmInstrInfo Mul_ovf_un_ = new VmInstrInfo(-356198078, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000106 RID: 262
|
||||
public readonly VmInstrInfo Conv_u_ = new VmInstrInfo(1795519976, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000108 RID: 264
|
||||
public readonly VmInstrInfo Ldelem_i_ = new VmInstrInfo(1499071663, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000109 RID: 265
|
||||
public readonly VmInstrInfo Ldarg_ = new VmInstrInfo(-1071239412, VmOperandType.Ot1UShort);
|
||||
|
||||
// Token: 0x0400010A RID: 266
|
||||
public readonly VmInstrInfo Conv_r_un_ = new VmInstrInfo(-23925463, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400010B RID: 267
|
||||
public readonly VmInstrInfo Ldc_i4_8_ = new VmInstrInfo(1119515810, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400010C RID: 268
|
||||
public readonly VmInstrInfo Conv_i8_ = new VmInstrInfo(1980167243, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400010D RID: 269
|
||||
public readonly VmInstrInfo Ldloc_1_ = new VmInstrInfo(704985473, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400010E RID: 270
|
||||
public readonly VmInstrInfo Ldelem_u2_ = new VmInstrInfo(-1142530894, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400010F RID: 271
|
||||
public readonly VmInstrInfo Throw_ = new VmInstrInfo(-958454075, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000110 RID: 272
|
||||
public readonly VmInstrInfo Cpblk_ = new VmInstrInfo(-123910492, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000111 RID: 273
|
||||
public readonly VmInstrInfo Ldind_u1_ = new VmInstrInfo(1476085916, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000113 RID: 275
|
||||
public readonly VmInstrInfo Stloc_2_ = new VmInstrInfo(392938325, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000114 RID: 276
|
||||
public readonly VmInstrInfo Ldarg_3_ = new VmInstrInfo(-1756998893, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000115 RID: 277
|
||||
public readonly VmInstrInfo Stloc_ = new VmInstrInfo(1447397361, VmOperandType.Ot1UShort);
|
||||
|
||||
// Token: 0x04000117 RID: 279
|
||||
public readonly VmInstrInfo Ldc_i4_5_ = new VmInstrInfo(-656328799, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000118 RID: 280
|
||||
public readonly VmInstrInfo Conv_ovf_u1_ = new VmInstrInfo(344575979, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400011A RID: 282
|
||||
public readonly VmInstrInfo Ldind_i4_ = new VmInstrInfo(234126039, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400011B RID: 283
|
||||
public readonly VmInstrInfo Switch_ = new VmInstrInfo(8625656, VmOperandType.Ot9IntArr);
|
||||
|
||||
// Token: 0x0400011C RID: 284
|
||||
public readonly VmInstrInfo Arglist_ = new VmInstrInfo(1783361912, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x0400011F RID: 287
|
||||
public readonly VmInstrInfo Shr_un_ = new VmInstrInfo(897680915, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000120 RID: 288
|
||||
public readonly VmInstrInfo Ldloc_2_ = new VmInstrInfo(-17993965, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000121 RID: 289
|
||||
public readonly VmInstrInfo Conv_ovf_u4_ = new VmInstrInfo(1596489702, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000122 RID: 290
|
||||
public readonly VmInstrInfo Bge_ = new VmInstrInfo(-1225693454, VmOperandType.Ot0UInt);
|
||||
|
||||
// Token: 0x04000123 RID: 291
|
||||
public readonly VmInstrInfo Ldloc_0_ = new VmInstrInfo(1021709264, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000124 RID: 292
|
||||
public readonly VmInstrInfo Bne_un_ = new VmInstrInfo(68951288, VmOperandType.Ot0UInt);
|
||||
|
||||
// Token: 0x04000126 RID: 294
|
||||
public readonly VmInstrInfo Stelem_i2_ = new VmInstrInfo(1223054294, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000127 RID: 295
|
||||
public readonly VmInstrInfo Sub_ovf_un_ = new VmInstrInfo(-851734976, VmOperandType.Ot11Nope);
|
||||
|
||||
// Token: 0x04000128 RID: 296
|
||||
public readonly VmInstrInfo Ret_ = new VmInstrInfo(1882847521, VmOperandType.Ot11Nope);
|
||||
#endregion
|
||||
}
|
||||
|
||||
public enum VmOperandType
|
||||
{
|
||||
Ot0UInt, Ot1UShort, Ot2Byte, Ot3UShort, Ot4Double, Ot5Int, Ot6SByte, Ot7Long, Ot8Byte, Ot9IntArr, Ot10Float, Ot11Nope, Ot12Int
|
||||
}
|
||||
// Token: 0x0200005F RID: 95
|
||||
public class VmInstrInfo // \u000F\u2005
|
||||
{
|
||||
// Token: 0x06000377 RID: 887 RVA: 0x00015B74 File Offset: 0x00013D74
|
||||
public VmInstrInfo(int id, VmOperandType operandType)
|
||||
{
|
||||
Id = id;
|
||||
OperandType = operandType;
|
||||
}
|
||||
|
||||
// Token: 0x06000378 RID: 888 RVA: 0x00015B8C File Offset: 0x00013D8C
|
||||
// Token: 0x06000379 RID: 889 RVA: 0x00015B94 File Offset: 0x00013D94
|
||||
// Token: 0x0400018F RID: 399
|
||||
public int Id { get; }
|
||||
|
||||
// Token: 0x0600037A RID: 890 RVA: 0x00015BA0 File Offset: 0x00013DA0
|
||||
// Token: 0x04000190 RID: 400
|
||||
public VmOperandType OperandType { get; }
|
||||
|
||||
// Token: 0x0600037B RID: 891 RVA: 0x00015BA8 File Offset: 0x00013DA8
|
||||
public override bool Equals(object o)
|
||||
{
|
||||
var p = o as VmInstrInfo;
|
||||
return (p != null) && EqualTo(p);
|
||||
}
|
||||
|
||||
// Token: 0x0600037C RID: 892 RVA: 0x00015BD0 File Offset: 0x00013DD0
|
||||
private bool EqualTo(VmInstrInfo p)
|
||||
{
|
||||
return p.Id== Id;
|
||||
}
|
||||
|
||||
// Token: 0x0600037D RID: 893 RVA: 0x00015BE0 File Offset: 0x00013DE0
|
||||
public static bool operator ==(VmInstrInfo o1, VmInstrInfo o2)
|
||||
{
|
||||
// ReSharper disable once PossibleNullReferenceException
|
||||
return o1.EqualTo(o2);
|
||||
}
|
||||
|
||||
// Token: 0x0600037E RID: 894 RVA: 0x00015BEC File Offset: 0x00013DEC
|
||||
public static bool operator !=(VmInstrInfo o1, VmInstrInfo o2)
|
||||
{
|
||||
return !(o1 == o2);
|
||||
}
|
||||
|
||||
// Token: 0x0600037F RID: 895 RVA: 0x00015BF8 File Offset: 0x00013DF8
|
||||
public override int GetHashCode()
|
||||
{
|
||||
return Id.GetHashCode();
|
||||
}
|
||||
|
||||
// Token: 0x06000380 RID: 896 RVA: 0x00015C14 File Offset: 0x00013E14
|
||||
public override string ToString()
|
||||
{
|
||||
return Id.ToString();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,42 @@
|
||||
namespace UnitTestProject.RefVm
|
||||
{
|
||||
// Token: 0x02000028 RID: 40
|
||||
public sealed class VmMethodHeader // \u0006
|
||||
{
|
||||
// Token: 0x06000120 RID: 288 RVA: 0x00005F08 File Offset: 0x00004108
|
||||
// Token: 0x06000121 RID: 289 RVA: 0x00005F10 File Offset: 0x00004110
|
||||
// Token: 0x04000047 RID: 71
|
||||
public LocalVarType[] LocalVarTypes /* \u0003 */ { get; set; }
|
||||
|
||||
// Token: 0x06000122 RID: 290 RVA: 0x00005F1C File Offset: 0x0000411C
|
||||
// Token: 0x06000123 RID: 291 RVA: 0x00005F24 File Offset: 0x00004124
|
||||
// Token: 0x0400004B RID: 75
|
||||
public ArgTypeToOutput[] ArgsTypeToOutput /* \u000E */ { get; set; }
|
||||
|
||||
// Token: 0x06000124 RID: 292 RVA: 0x00005F30 File Offset: 0x00004130
|
||||
// Token: 0x06000125 RID: 293 RVA: 0x00005F38 File Offset: 0x00004138
|
||||
// Token: 0x04000048 RID: 72
|
||||
public string Name /* \u0002 */ { get; set; }
|
||||
|
||||
// Token: 0x06000126 RID: 294 RVA: 0x00005F44 File Offset: 0x00004144
|
||||
// Token: 0x06000127 RID: 295 RVA: 0x00005F4C File Offset: 0x0000414C
|
||||
// Token: 0x04000046 RID: 70
|
||||
public int ClassId /* \u0002 */ { get; set; }
|
||||
|
||||
// Token: 0x06000128 RID: 296 RVA: 0x00005F58 File Offset: 0x00004158
|
||||
// Token: 0x06000129 RID: 297 RVA: 0x00005F60 File Offset: 0x00004160
|
||||
// Token: 0x04000049 RID: 73
|
||||
public int ReturnTypeId /* \u0008 */ { get; set; }
|
||||
|
||||
// Token: 0x0600012A RID: 298 RVA: 0x00005F6C File Offset: 0x0000416C
|
||||
// Token: 0x0600012B RID: 299 RVA: 0x00005F74 File Offset: 0x00004174
|
||||
// Token: 0x0400004A RID: 74
|
||||
public byte Flags /* \u0006 */ { private get; set; }
|
||||
|
||||
// Token: 0x0600012C RID: 300 RVA: 0x00005F80 File Offset: 0x00004180
|
||||
public bool IsStatic() // \u0002
|
||||
{
|
||||
return (Flags & 2) > 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,96 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
|
||||
namespace UnitTestProject.RefVm
|
||||
{
|
||||
internal static class VmPosParser // \u0006\u2006
|
||||
{
|
||||
// Token: 0x0600016A RID: 362 RVA: 0x00007810 File Offset: 0x00005A10
|
||||
public static byte[] Parse(string pos) // dest
|
||||
{
|
||||
if (pos == null)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
var memoryStream = new MemoryStream(pos.Length * 4 / 5);
|
||||
byte[] result;
|
||||
using(memoryStream)
|
||||
{
|
||||
var cnt = 0;
|
||||
var val = 0u;
|
||||
foreach (var c in pos)
|
||||
{
|
||||
if (c == 'z' && cnt == 0)
|
||||
{
|
||||
WriteDwPart(memoryStream, val, 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (c< '!' || c> 'u')
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
checked
|
||||
{
|
||||
val += (uint)(Arr[cnt] * (ulong)checked(c - '!'));
|
||||
}
|
||||
cnt++;
|
||||
if (cnt == 5)
|
||||
{
|
||||
WriteDwPart(memoryStream, val, 0);
|
||||
cnt = 0;
|
||||
val = 0u;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (cnt == 1)
|
||||
{
|
||||
throw new Exception();
|
||||
}
|
||||
if (cnt > 1)
|
||||
{
|
||||
for (var j = cnt; j < 5; j++)
|
||||
{
|
||||
checked
|
||||
{
|
||||
val += 84u * Arr[j];
|
||||
}
|
||||
}
|
||||
WriteDwPart(memoryStream, val, 5 - cnt);
|
||||
}
|
||||
result = memoryStream.ToArray();
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// Token: 0x0600016B RID: 363 RVA: 0x00007900 File Offset: 0x00005B00
|
||||
private static void WriteDwPart(Stream dest, uint val, int ignoreLow) // dest
|
||||
{
|
||||
dest.WriteByte((byte)(val >> 24));
|
||||
if (ignoreLow == 3)
|
||||
{
|
||||
return;
|
||||
}
|
||||
dest.WriteByte((byte)(val >> 16 & 255u));
|
||||
if (ignoreLow == 2)
|
||||
{
|
||||
return;
|
||||
}
|
||||
dest.WriteByte((byte)(val >> 8 & 255u));
|
||||
if (ignoreLow == 1)
|
||||
{
|
||||
return;
|
||||
}
|
||||
dest.WriteByte((byte)(val & 255u));
|
||||
}
|
||||
|
||||
// Token: 0x04000131 RID: 305
|
||||
private static readonly uint[] Arr = {
|
||||
52200625u,
|
||||
614125u,
|
||||
7225u,
|
||||
85u,
|
||||
1u
|
||||
};
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,116 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
|
||||
namespace UnitTestProject.RefVm
|
||||
{
|
||||
// Token: 0x02000021 RID: 33
|
||||
public sealed class VmStreamWrapper : Stream // \u0005\u2005
|
||||
{
|
||||
// Token: 0x060000CB RID: 203 RVA: 0x00004A20 File Offset: 0x00002C20
|
||||
public VmStreamWrapper(Stream src, int xorKey)
|
||||
{
|
||||
SetStream(src);
|
||||
_xorKey = xorKey;
|
||||
}
|
||||
|
||||
// Token: 0x060000CC RID: 204 RVA: 0x00004A38 File Offset: 0x00002C38
|
||||
public Stream GetStream() // \u0008\u2003\u2003\u2001\u2001\u2000\u2000\u2008\u2000\u2001\u2000\u2008\u200A\u2008\u200B\u2003\u200B
|
||||
{
|
||||
return _srcStream;
|
||||
}
|
||||
|
||||
// Token: 0x060000CD RID: 205 RVA: 0x00004A40 File Offset: 0x00002C40
|
||||
private void SetStream(Stream src) // \u0002
|
||||
{
|
||||
_srcStream = src;
|
||||
}
|
||||
|
||||
// Token: 0x17000001 RID: 1
|
||||
// (get) Token: 0x060000CE RID: 206 RVA: 0x00004A4C File Offset: 0x00002C4C
|
||||
public override bool CanRead => GetStream().CanRead;
|
||||
|
||||
// Token: 0x17000002 RID: 2
|
||||
// (get) Token: 0x060000CF RID: 207 RVA: 0x00004A5C File Offset: 0x00002C5C
|
||||
public override bool CanSeek => GetStream().CanSeek;
|
||||
|
||||
// Token: 0x17000003 RID: 3
|
||||
// (get) Token: 0x060000D0 RID: 208 RVA: 0x00004A6C File Offset: 0x00002C6C
|
||||
public override bool CanWrite => GetStream().CanWrite;
|
||||
|
||||
// Token: 0x060000D1 RID: 209 RVA: 0x00004A7C File Offset: 0x00002C7C
|
||||
public override void Flush()
|
||||
{
|
||||
GetStream().Flush();
|
||||
}
|
||||
|
||||
// Token: 0x17000004 RID: 4
|
||||
// (get) Token: 0x060000D2 RID: 210 RVA: 0x00004A8C File Offset: 0x00002C8C
|
||||
public override long Length => GetStream().Length;
|
||||
|
||||
// Token: 0x17000005 RID: 5
|
||||
// (get) Token: 0x060000D3 RID: 211 RVA: 0x00004A9C File Offset: 0x00002C9C
|
||||
// (set) Token: 0x060000D4 RID: 212 RVA: 0x00004AAC File Offset: 0x00002CAC
|
||||
public override long Position
|
||||
{
|
||||
get
|
||||
{
|
||||
return GetStream().Position;
|
||||
}
|
||||
set
|
||||
{
|
||||
GetStream().Position = value;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060000D5 RID: 213 RVA: 0x00004ABC File Offset: 0x00002CBC
|
||||
private byte Xor(byte data, long key2) // \u0002
|
||||
{
|
||||
var b = (byte)(_xorKey ^ -559030707 ^ (int)((uint)key2));
|
||||
return (byte)(data ^ b);
|
||||
}
|
||||
|
||||
// Token: 0x060000D6 RID: 214 RVA: 0x00004AE0 File Offset: 0x00002CE0
|
||||
public override void Write(byte[] data, int offset, int size)
|
||||
{
|
||||
var array = new byte[size];
|
||||
Buffer.BlockCopy(data, offset, array, 0, size);
|
||||
var position = Position;
|
||||
for (var i = 0; i < size; i++)
|
||||
{
|
||||
array[i] = Xor(array[i], position + i);
|
||||
}
|
||||
GetStream().Write(array, 0, size);
|
||||
}
|
||||
|
||||
// Token: 0x060000D7 RID: 215 RVA: 0x00004B30 File Offset: 0x00002D30
|
||||
public override int Read(byte[] data, int offset, int size)
|
||||
{
|
||||
var position = Position;
|
||||
var array = new byte[size];
|
||||
var num = GetStream().Read(array, 0, size);
|
||||
for (var i = 0; i < num; i++)
|
||||
{
|
||||
data[i + offset] = Xor(array[i], position + i);
|
||||
}
|
||||
return num;
|
||||
}
|
||||
|
||||
// Token: 0x060000D8 RID: 216 RVA: 0x00004B7C File Offset: 0x00002D7C
|
||||
public override long Seek(long pos, SeekOrigin from)
|
||||
{
|
||||
return GetStream().Seek(pos, from);
|
||||
}
|
||||
|
||||
// Token: 0x060000D9 RID: 217 RVA: 0x00004B8C File Offset: 0x00002D8C
|
||||
public override void SetLength(long val)
|
||||
{
|
||||
GetStream().SetLength(val);
|
||||
}
|
||||
|
||||
// Token: 0x0400002A RID: 42
|
||||
private readonly int _xorKey; // \u0002
|
||||
|
||||
// Token: 0x0400002B RID: 43
|
||||
private Stream _srcStream; // \u0003
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user