niko
953 lines
24 KiB
C#
953 lines
24 KiB
C#
using System;
|
|
using System.Text;
|
|
using BestHTTP.SecureProtocol.Org.BouncyCastle.Math;
|
|
using Cpp2IlInjected;
|
|
|
|
namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities
|
|
{
|
|
// Token: 0x02001920 RID: 6432
|
|
[Token(Token = "0x2001920")]
|
|
public abstract class Arrays
|
|
{
|
|
// Token: 0x06009809 RID: 38921 RVA: 0x001F516C File Offset: 0x001F336C
|
|
[Token(Token = "0x6009809")]
|
|
[Address(RVA = "0x18D22F0", Offset = "0x18D10F0", VA = "0x1818D22F0")]
|
|
public static bool AreAllZeroes(byte[] buf, int off, int len)
|
|
{
|
|
int num = 0;
|
|
if (len > 0)
|
|
{
|
|
}
|
|
return num == 0;
|
|
}
|
|
|
|
// Token: 0x0600980A RID: 38922 RVA: 0x001F518C File Offset: 0x001F338C
|
|
[Token(Token = "0x600980A")]
|
|
[Address(RVA = "0x18D24E0", Offset = "0x18D12E0", VA = "0x1818D24E0")]
|
|
public static bool AreEqual(bool[] a, bool[] b)
|
|
{
|
|
if (a != b)
|
|
{
|
|
if (a != 0 && b != 0)
|
|
{
|
|
int length = a.Length;
|
|
int length2 = b.Length;
|
|
if (length != length2 || length != 0)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x0600980B RID: 38923 RVA: 0x001F51C4 File Offset: 0x001F33C4
|
|
[Token(Token = "0x600980B")]
|
|
[Address(RVA = "0x18D2410", Offset = "0x18D1210", VA = "0x1818D2410")]
|
|
public static bool AreEqual(char[] a, char[] b)
|
|
{
|
|
if (a != b)
|
|
{
|
|
if (a != 0 && b != 0)
|
|
{
|
|
int length = a.Length;
|
|
int length2 = b.Length;
|
|
if (length == length2)
|
|
{
|
|
if (length != 0)
|
|
{
|
|
char c = b[length];
|
|
while ("{il2cpp array field a->}" == c)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x0600980C RID: 38924 RVA: 0x001F520C File Offset: 0x001F340C
|
|
[Token(Token = "0x600980C")]
|
|
[Address(RVA = "0x18D2660", Offset = "0x18D1460", VA = "0x1818D2660")]
|
|
public static bool AreEqual(byte[] a, byte[] b)
|
|
{
|
|
if (a != b)
|
|
{
|
|
if (a != 0 && b != 0)
|
|
{
|
|
int length = a.Length;
|
|
int length2 = b.Length;
|
|
if (length != length2 || length != 0)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x0600980D RID: 38925 RVA: 0x001F5244 File Offset: 0x001F3444
|
|
[Token(Token = "0x600980D")]
|
|
[Address(RVA = "0x18D2720", Offset = "0x18D1520", VA = "0x1818D2720")]
|
|
[Obsolete]
|
|
public static bool AreSame(byte[] a, byte[] b)
|
|
{
|
|
if (a != b)
|
|
{
|
|
if (a != 0 && b != 0)
|
|
{
|
|
int length = a.Length;
|
|
int length2 = b.Length;
|
|
if (length != length2 || length != 0)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x0600980E RID: 38926 RVA: 0x001F527C File Offset: 0x001F347C
|
|
[Token(Token = "0x600980E")]
|
|
[Address(RVA = "0x18D2FF0", Offset = "0x18D1DF0", VA = "0x1818D2FF0")]
|
|
public static bool ConstantTimeAreEqual(byte[] a, byte[] b)
|
|
{
|
|
int length = b.Length;
|
|
int length2 = a.Length;
|
|
if (length2 == length)
|
|
{
|
|
int num = 0;
|
|
if (length2 != 0)
|
|
{
|
|
while (length2 != 0)
|
|
{
|
|
}
|
|
}
|
|
return num == 0;
|
|
}
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x0600980F RID: 38927 RVA: 0x001F52B4 File Offset: 0x001F34B4
|
|
[Token(Token = "0x600980F")]
|
|
[Address(RVA = "0x18D25A0", Offset = "0x18D13A0", VA = "0x1818D25A0")]
|
|
public static bool AreEqual(int[] a, int[] b)
|
|
{
|
|
if (a != b)
|
|
{
|
|
if (a != 0 && b != 0)
|
|
{
|
|
int length = a.Length;
|
|
int length2 = b.Length;
|
|
if (length == length2)
|
|
{
|
|
if (length != 0)
|
|
{
|
|
int num = b[length];
|
|
while ("{il2cpp array field a->}" == num)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x06009810 RID: 38928 RVA: 0x001F52FC File Offset: 0x001F34FC
|
|
[Token(Token = "0x6009810")]
|
|
[Address(RVA = "0x18D2350", Offset = "0x18D1150", VA = "0x1818D2350")]
|
|
[CLSCompliant(false)]
|
|
public static bool AreEqual(uint[] a, uint[] b)
|
|
{
|
|
if (a != b)
|
|
{
|
|
if (a != 0 && b != 0)
|
|
{
|
|
int length = a.Length;
|
|
int length2 = b.Length;
|
|
if (length == length2)
|
|
{
|
|
if (length != 0)
|
|
{
|
|
uint num = b[length];
|
|
while ("{il2cpp array field a->}" == num)
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x06009811 RID: 38929 RVA: 0x001F5344 File Offset: 0x001F3544
|
|
[Token(Token = "0x6009811")]
|
|
[Address(RVA = "0x18D3D10", Offset = "0x18D2B10", VA = "0x1818D3D10")]
|
|
private static bool HaveSameContents(bool[] a, bool[] b)
|
|
{
|
|
int length = a.Length;
|
|
int length2 = b.Length;
|
|
if (length == length2)
|
|
{
|
|
if (length != 0)
|
|
{
|
|
}
|
|
return true;
|
|
}
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009812 RID: 38930 RVA: 0x001F5370 File Offset: 0x001F3570
|
|
[Token(Token = "0x6009812")]
|
|
[Address(RVA = "0x18D3D90", Offset = "0x18D2B90", VA = "0x1818D3D90")]
|
|
private static bool HaveSameContents(char[] a, char[] b)
|
|
{
|
|
int length = a.Length;
|
|
int length2 = b.Length;
|
|
if (length == length2)
|
|
{
|
|
if (length != 0)
|
|
{
|
|
char c = b[length];
|
|
}
|
|
return true;
|
|
}
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009813 RID: 38931 RVA: 0x001F53A4 File Offset: 0x001F35A4
|
|
[Token(Token = "0x6009813")]
|
|
[Address(RVA = "0x18D3D10", Offset = "0x18D2B10", VA = "0x1818D3D10")]
|
|
private static bool HaveSameContents(byte[] a, byte[] b)
|
|
{
|
|
int length = a.Length;
|
|
int length2 = b.Length;
|
|
if (length == length2)
|
|
{
|
|
if (length != 0)
|
|
{
|
|
}
|
|
return true;
|
|
}
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009814 RID: 38932 RVA: 0x001F53D0 File Offset: 0x001F35D0
|
|
[Token(Token = "0x6009814")]
|
|
[Address(RVA = "0x18D3C90", Offset = "0x18D2A90", VA = "0x1818D3C90")]
|
|
private static bool HaveSameContents(int[] a, int[] b)
|
|
{
|
|
int length = a.Length;
|
|
int length2 = b.Length;
|
|
if (length == length2)
|
|
{
|
|
if (length != 0)
|
|
{
|
|
int num = b[length];
|
|
}
|
|
return true;
|
|
}
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009815 RID: 38933 RVA: 0x001F5404 File Offset: 0x001F3604
|
|
[Token(Token = "0x6009815")]
|
|
[Address(RVA = "0x18D3C90", Offset = "0x18D2A90", VA = "0x1818D3C90")]
|
|
private static bool HaveSameContents(uint[] a, uint[] b)
|
|
{
|
|
int length = a.Length;
|
|
int length2 = b.Length;
|
|
if (length == length2)
|
|
{
|
|
if (length != 0)
|
|
{
|
|
uint num = b[length];
|
|
}
|
|
return true;
|
|
}
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009816 RID: 38934 RVA: 0x001F5438 File Offset: 0x001F3638
|
|
[Token(Token = "0x6009816")]
|
|
[Address(RVA = "0x18D4260", Offset = "0x18D3060", VA = "0x1818D4260")]
|
|
public static string ToString(object[] a)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder(91);
|
|
if (a.Length != 0)
|
|
{
|
|
object obj = a[0];
|
|
StringBuilder stringBuilder2 = stringBuilder.Append(obj);
|
|
if ((uint)1 < (uint)a.Length)
|
|
{
|
|
object obj2;
|
|
StringBuilder stringBuilder3 = stringBuilder.Append(", ").Append(obj2);
|
|
}
|
|
}
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009817 RID: 38935 RVA: 0x001F5488 File Offset: 0x001F3688
|
|
[Token(Token = "0x6009817")]
|
|
[Address(RVA = "0x18D3AA0", Offset = "0x18D28A0", VA = "0x1818D3AA0")]
|
|
public static int GetHashCode(byte[] data)
|
|
{
|
|
if (data != 0)
|
|
{
|
|
int length = data.Length;
|
|
int num = length - 1;
|
|
long num2 = (long)((length + 1) * (int)((uint)257));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x06009818 RID: 38936 RVA: 0x001F54B8 File Offset: 0x001F36B8
|
|
[Token(Token = "0x6009818")]
|
|
[Address(RVA = "0x18D3A40", Offset = "0x18D2840", VA = "0x1818D3A40")]
|
|
public static int GetHashCode(byte[] data, int off, int len)
|
|
{
|
|
if (data != 0)
|
|
{
|
|
int num = len + 1;
|
|
int length = data.Length;
|
|
long num2 = (long)(num * (int)((uint)257));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x06009819 RID: 38937 RVA: 0x001F54E4 File Offset: 0x001F36E4
|
|
[Token(Token = "0x6009819")]
|
|
[Address(RVA = "0x18D39E0", Offset = "0x18D27E0", VA = "0x1818D39E0")]
|
|
public static int GetHashCode(int[] data)
|
|
{
|
|
if (data != 0)
|
|
{
|
|
int length = data.Length;
|
|
int num = length - 1;
|
|
int num2 = length + 1;
|
|
return num;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x0600981A RID: 38938 RVA: 0x001F5510 File Offset: 0x001F3710
|
|
[Token(Token = "0x600981A")]
|
|
[Address(RVA = "0x18D3980", Offset = "0x18D2780", VA = "0x1818D3980")]
|
|
public static int GetHashCode(int[] data, int off, int len)
|
|
{
|
|
if (data != 0)
|
|
{
|
|
int num = len + 1;
|
|
int length = data.Length;
|
|
return off;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x0600981B RID: 38939 RVA: 0x001F5538 File Offset: 0x001F3738
|
|
[Token(Token = "0x600981B")]
|
|
[Address(RVA = "0x18D39E0", Offset = "0x18D27E0", VA = "0x1818D39E0")]
|
|
[CLSCompliant(false)]
|
|
public static int GetHashCode(uint[] data)
|
|
{
|
|
if (data != 0)
|
|
{
|
|
int length = data.Length;
|
|
int num = length - 1;
|
|
int num2 = length + 1;
|
|
uint num3 = data[num];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x0600981C RID: 38940 RVA: 0x001F5568 File Offset: 0x001F3768
|
|
[Token(Token = "0x600981C")]
|
|
[Address(RVA = "0x18D3980", Offset = "0x18D2780", VA = "0x1818D3980")]
|
|
[CLSCompliant(false)]
|
|
public static int GetHashCode(uint[] data, int off, int len)
|
|
{
|
|
if (data != 0)
|
|
{
|
|
int num = len + 1;
|
|
int length = data.Length;
|
|
uint num2 = data[off];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x0600981D RID: 38941 RVA: 0x001F5594 File Offset: 0x001F3794
|
|
[Token(Token = "0x600981D")]
|
|
[Address(RVA = "0x18D3B00", Offset = "0x18D2900", VA = "0x1818D3B00")]
|
|
[CLSCompliant(false)]
|
|
public static int GetHashCode(ulong[] data)
|
|
{
|
|
if (data != 0)
|
|
{
|
|
int length = data.Length;
|
|
int num = length - 1;
|
|
long num2 = (long)((length + 1) * (int)((uint)257));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x0600981E RID: 38942 RVA: 0x001F55C4 File Offset: 0x001F37C4
|
|
[Token(Token = "0x600981E")]
|
|
[Address(RVA = "0x18D3B70", Offset = "0x18D2970", VA = "0x1818D3B70")]
|
|
[CLSCompliant(false)]
|
|
public static int GetHashCode(ulong[] data, int off, int len)
|
|
{
|
|
if (data != 0)
|
|
{
|
|
int num = len + 1;
|
|
int length = data.Length;
|
|
long num2 = (long)(num * (int)((uint)257));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x0600981F RID: 38943 RVA: 0x001F55F0 File Offset: 0x001F37F0
|
|
[Token(Token = "0x600981F")]
|
|
[Address(RVA = "0x18D2B40", Offset = "0x18D1940", VA = "0x1818D2B40")]
|
|
public static byte[] Clone(byte[] data)
|
|
{
|
|
while (data != 0)
|
|
{
|
|
}
|
|
}
|
|
|
|
// Token: 0x06009820 RID: 38944 RVA: 0x001F5604 File Offset: 0x001F3804
|
|
[Token(Token = "0x6009820")]
|
|
[Address(RVA = "0x18D2820", Offset = "0x18D1620", VA = "0x1818D2820")]
|
|
public static byte[] Clone(byte[] data, byte[] existing)
|
|
{
|
|
if (data != 0)
|
|
{
|
|
if (existing != 0)
|
|
{
|
|
int length = existing.Length;
|
|
if (length == data.Length)
|
|
{
|
|
int num = 0;
|
|
int num2 = 0;
|
|
Array.Copy(data, num2, existing, num, length);
|
|
return existing;
|
|
}
|
|
}
|
|
return Arrays.Clone(data);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06009821 RID: 38945 RVA: 0x001F5644 File Offset: 0x001F3844
|
|
[Token(Token = "0x6009821")]
|
|
[Address(RVA = "0x18D2A40", Offset = "0x18D1840", VA = "0x1818D2A40")]
|
|
public static int[] Clone(int[] data)
|
|
{
|
|
while (data != 0)
|
|
{
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x06009822 RID: 38946 RVA: 0x001F5658 File Offset: 0x001F3858
|
|
[Token(Token = "0x6009822")]
|
|
[Address(RVA = "0x18D2BC0", Offset = "0x18D19C0", VA = "0x1818D2BC0")]
|
|
internal static uint[] Clone(uint[] data)
|
|
{
|
|
while (data != 0)
|
|
{
|
|
}
|
|
}
|
|
|
|
// Token: 0x06009823 RID: 38947 RVA: 0x001F566C File Offset: 0x001F386C
|
|
[Token(Token = "0x6009823")]
|
|
[Address(RVA = "0x18D28D0", Offset = "0x18D16D0", VA = "0x1818D28D0")]
|
|
public static long[] Clone(long[] data)
|
|
{
|
|
while (data != 0)
|
|
{
|
|
}
|
|
}
|
|
|
|
// Token: 0x06009824 RID: 38948 RVA: 0x001F5680 File Offset: 0x001F3880
|
|
[Token(Token = "0x6009824")]
|
|
[Address(RVA = "0x18D2AC0", Offset = "0x18D18C0", VA = "0x1818D2AC0")]
|
|
[CLSCompliant(false)]
|
|
public static ulong[] Clone(ulong[] data)
|
|
{
|
|
while (data != 0)
|
|
{
|
|
}
|
|
}
|
|
|
|
// Token: 0x06009825 RID: 38949 RVA: 0x001F5694 File Offset: 0x001F3894
|
|
[Token(Token = "0x6009825")]
|
|
[Address(RVA = "0x18D2950", Offset = "0x18D1750", VA = "0x1818D2950")]
|
|
[CLSCompliant(false)]
|
|
public static ulong[] Clone(ulong[] data, ulong[] existing)
|
|
{
|
|
if (data == 0 || existing == 0)
|
|
{
|
|
return;
|
|
}
|
|
int length = existing.Length;
|
|
if (length == data.Length)
|
|
{
|
|
int num = 0;
|
|
int num2 = 0;
|
|
Array.Copy(data, num2, existing, num, length);
|
|
return existing;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06009826 RID: 38950 RVA: 0x001F56D0 File Offset: 0x001F38D0
|
|
[Token(Token = "0x6009826")]
|
|
[Address(RVA = "0x18D30F0", Offset = "0x18D1EF0", VA = "0x1818D30F0")]
|
|
public static bool Contains(byte[] a, byte n)
|
|
{
|
|
int num = 0;
|
|
int length = a.Length;
|
|
if (num < length)
|
|
{
|
|
num++;
|
|
return true;
|
|
}
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009827 RID: 38951 RVA: 0x001F56F8 File Offset: 0x001F38F8
|
|
[Token(Token = "0x6009827")]
|
|
[Address(RVA = "0x18D3090", Offset = "0x18D1E90", VA = "0x1818D3090")]
|
|
public static bool Contains(short[] a, short n)
|
|
{
|
|
int num = 0;
|
|
int length = a.Length;
|
|
if (num < length)
|
|
{
|
|
if ("{il2cpp array field a->}" != n)
|
|
{
|
|
num++;
|
|
}
|
|
return true;
|
|
}
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009828 RID: 38952 RVA: 0x001F5728 File Offset: 0x001F3928
|
|
[Token(Token = "0x6009828")]
|
|
[Address(RVA = "0x18D3150", Offset = "0x18D1F50", VA = "0x1818D3150")]
|
|
public static bool Contains(int[] a, int n)
|
|
{
|
|
int num = 0;
|
|
int length = a.Length;
|
|
if (num < length)
|
|
{
|
|
if ("{il2cpp array field a->}" != n)
|
|
{
|
|
num++;
|
|
}
|
|
return true;
|
|
}
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009829 RID: 38953 RVA: 0x001F5758 File Offset: 0x001F3958
|
|
[Token(Token = "0x6009829")]
|
|
[Address(RVA = "0x18D3930", Offset = "0x18D2730", VA = "0x1818D3930")]
|
|
public static void Fill(byte[] buf, byte b)
|
|
{
|
|
int num = buf.Length;
|
|
if (num > 0)
|
|
{
|
|
num--;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600982A RID: 38954 RVA: 0x001F577C File Offset: 0x001F397C
|
|
[Token(Token = "0x600982A")]
|
|
[Address(RVA = "0x18D38E0", Offset = "0x18D26E0", VA = "0x1818D38E0")]
|
|
public static void Fill(byte[] buf, int from, int to, byte b)
|
|
{
|
|
if (from < to)
|
|
{
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600982B RID: 38955 RVA: 0x001F5794 File Offset: 0x001F3994
|
|
[Token(Token = "0x600982B")]
|
|
[Address(RVA = "0x18D3780", Offset = "0x18D2580", VA = "0x1818D3780")]
|
|
public static byte[] CopyOf(byte[] data, int newLength)
|
|
{
|
|
byte[] array = new byte[newLength];
|
|
int length = data.Length;
|
|
int num = Math.Min(newLength, length);
|
|
int num2 = 0;
|
|
int num3 = 0;
|
|
Array.Copy(data, num3, array, num2, num);
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x0600982C RID: 38956 RVA: 0x001F57D0 File Offset: 0x001F39D0
|
|
[Token(Token = "0x600982C")]
|
|
[Address(RVA = "0x18D3620", Offset = "0x18D2420", VA = "0x1818D3620")]
|
|
public static char[] CopyOf(char[] data, int newLength)
|
|
{
|
|
char[] array = new char[newLength];
|
|
int length = data.Length;
|
|
int num = Math.Min(newLength, length);
|
|
int num2 = 0;
|
|
int num3 = 0;
|
|
Array.Copy(data, num3, array, num2, num);
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x0600982D RID: 38957 RVA: 0x001F580C File Offset: 0x001F3A0C
|
|
[Token(Token = "0x600982D")]
|
|
[Address(RVA = "0x18D3830", Offset = "0x18D2630", VA = "0x1818D3830")]
|
|
public static int[] CopyOf(int[] data, int newLength)
|
|
{
|
|
int[] array = new int[newLength];
|
|
int length = data.Length;
|
|
int num = Math.Min(newLength, length);
|
|
int num2 = 0;
|
|
int num3 = 0;
|
|
Array.Copy(data, num3, array, num2, num);
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x0600982E RID: 38958 RVA: 0x001F5848 File Offset: 0x001F3A48
|
|
[Token(Token = "0x600982E")]
|
|
[Address(RVA = "0x18D36D0", Offset = "0x18D24D0", VA = "0x1818D36D0")]
|
|
public static long[] CopyOf(long[] data, int newLength)
|
|
{
|
|
long[] array = new long[newLength];
|
|
int length = data.Length;
|
|
int num = Math.Min(newLength, length);
|
|
int num2 = 0;
|
|
int num3 = 0;
|
|
Array.Copy(data, num3, array, num2, num);
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x0600982F RID: 38959 RVA: 0x001F5884 File Offset: 0x001F3A84
|
|
[Token(Token = "0x600982F")]
|
|
[Address(RVA = "0x18D3570", Offset = "0x18D2370", VA = "0x1818D3570")]
|
|
public static BigInteger[] CopyOf(BigInteger[] data, int newLength)
|
|
{
|
|
BigInteger[] array = new BigInteger[newLength];
|
|
int length = data.Length;
|
|
int num = Math.Min(newLength, length);
|
|
int num2 = 0;
|
|
int num3 = 0;
|
|
Array.Copy(data, num3, array, num2, num);
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x06009830 RID: 38960 RVA: 0x001F58C0 File Offset: 0x001F3AC0
|
|
[Token(Token = "0x6009830")]
|
|
[Address(RVA = "0x18D32A0", Offset = "0x18D20A0", VA = "0x1818D32A0")]
|
|
public static byte[] CopyOfRange(byte[] data, int from, int to)
|
|
{
|
|
int length = Arrays.GetLength(from, from);
|
|
byte[] array = new byte[from];
|
|
int num = data.Length;
|
|
num -= from;
|
|
int num2 = Math.Min(to, num);
|
|
int num3 = 0;
|
|
Array.Copy(data, from, array, num3, num2);
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x06009831 RID: 38961 RVA: 0x001F5908 File Offset: 0x001F3B08
|
|
[Token(Token = "0x6009831")]
|
|
[Address(RVA = "0x18D3390", Offset = "0x18D2190", VA = "0x1818D3390")]
|
|
public static int[] CopyOfRange(int[] data, int from, int to)
|
|
{
|
|
int length = Arrays.GetLength(from, from);
|
|
int[] array = new int[from];
|
|
int num = data.Length;
|
|
num -= from;
|
|
int num2 = Math.Min(to, num);
|
|
int num3 = 0;
|
|
Array.Copy(data, from, array, num3, num2);
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x06009832 RID: 38962 RVA: 0x001F5950 File Offset: 0x001F3B50
|
|
[Token(Token = "0x6009832")]
|
|
[Address(RVA = "0x18D31B0", Offset = "0x18D1FB0", VA = "0x1818D31B0")]
|
|
public static long[] CopyOfRange(long[] data, int from, int to)
|
|
{
|
|
int length = Arrays.GetLength(from, from);
|
|
long[] array = new long[from];
|
|
int num = data.Length;
|
|
num -= from;
|
|
int num2 = Math.Min(to, num);
|
|
int num3 = 0;
|
|
Array.Copy(data, from, array, num3, num2);
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x06009833 RID: 38963 RVA: 0x001F5998 File Offset: 0x001F3B98
|
|
[Token(Token = "0x6009833")]
|
|
[Address(RVA = "0x18D3480", Offset = "0x18D2280", VA = "0x1818D3480")]
|
|
public static BigInteger[] CopyOfRange(BigInteger[] data, int from, int to)
|
|
{
|
|
int length = Arrays.GetLength(from, from);
|
|
BigInteger[] array = new BigInteger[from];
|
|
int num = data.Length;
|
|
num -= from;
|
|
int num2 = Math.Min(to, num);
|
|
int num3 = 0;
|
|
Array.Copy(data, from, array, num3, num2);
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x06009834 RID: 38964 RVA: 0x001F59E0 File Offset: 0x001F3BE0
|
|
[Token(Token = "0x6009834")]
|
|
[Address(RVA = "0x18D3BE0", Offset = "0x18D29E0", VA = "0x1818D3BE0")]
|
|
private static int GetLength(int from, int to)
|
|
{
|
|
return to;
|
|
}
|
|
|
|
// Token: 0x06009835 RID: 38965 RVA: 0x001F5A00 File Offset: 0x001F3C00
|
|
[Token(Token = "0x6009835")]
|
|
[Address(RVA = "0x18D2210", Offset = "0x18D1010", VA = "0x1818D2210")]
|
|
public static byte[] Append(byte[] a, byte b)
|
|
{
|
|
if (a != 0)
|
|
{
|
|
int length = a.Length;
|
|
byte[] array = new byte[length + 1];
|
|
int num = 0;
|
|
int num2 = 0;
|
|
Array.Copy(a, num2, array, num, length);
|
|
return array;
|
|
}
|
|
(new byte[1])[0] = b;
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009836 RID: 38966 RVA: 0x001F5A48 File Offset: 0x001F3C48
|
|
[Token(Token = "0x6009836")]
|
|
[Address(RVA = "0x18D2050", Offset = "0x18D0E50", VA = "0x1818D2050")]
|
|
public static short[] Append(short[] a, short b)
|
|
{
|
|
if (a != 0)
|
|
{
|
|
int length = a.Length;
|
|
short[] array = new short[length + 1];
|
|
int num = 0;
|
|
int num2 = 0;
|
|
Array.Copy(a, num2, array, num, length);
|
|
array[0] = b;
|
|
return array;
|
|
}
|
|
(new short[1])[0] = b;
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009837 RID: 38967 RVA: 0x001F5A98 File Offset: 0x001F3C98
|
|
[Token(Token = "0x6009837")]
|
|
[Address(RVA = "0x18D2130", Offset = "0x18D0F30", VA = "0x1818D2130")]
|
|
public static int[] Append(int[] a, int b)
|
|
{
|
|
if (a != 0)
|
|
{
|
|
int length = a.Length;
|
|
int[] array = new int[length + 1];
|
|
int num = 0;
|
|
int num2 = 0;
|
|
Array.Copy(a, num2, array, num, length);
|
|
array[0] = b;
|
|
return array;
|
|
}
|
|
(new int[1])[0] = b;
|
|
throw new NullReferenceException();
|
|
}
|
|
|
|
// Token: 0x06009838 RID: 38968 RVA: 0x001F5AE8 File Offset: 0x001F3CE8
|
|
[Token(Token = "0x6009838")]
|
|
[Address(RVA = "0x18D2DD0", Offset = "0x18D1BD0", VA = "0x1818D2DD0")]
|
|
public static byte[] Concatenate(byte[] a, byte[] b)
|
|
{
|
|
if (a == 0)
|
|
{
|
|
return Arrays.Clone(b);
|
|
}
|
|
if (b != 0)
|
|
{
|
|
byte[] array = new byte[b.Length];
|
|
int length = a.Length;
|
|
int num = 0;
|
|
int num2 = 0;
|
|
Array.Copy(a, num2, array, num, length);
|
|
int length2 = b.Length;
|
|
int length3 = a.Length;
|
|
int num3 = 0;
|
|
Array.Copy(b, num3, array, length3, length2);
|
|
return array;
|
|
}
|
|
return Arrays.Clone(a);
|
|
}
|
|
|
|
// Token: 0x06009839 RID: 38969 RVA: 0x001F5B50 File Offset: 0x001F3D50
|
|
[Token(Token = "0x6009839")]
|
|
[Address(RVA = "0x18D2C40", Offset = "0x18D1A40", VA = "0x1818D2C40")]
|
|
public static byte[] ConcatenateAll(params byte[][] vs)
|
|
{
|
|
byte[][] array = new byte[vs.Length][];
|
|
int num = 0;
|
|
int num2 = 0;
|
|
int num3 = 0;
|
|
int num4 = 0;
|
|
int length = vs.Length;
|
|
if (num4 < length)
|
|
{
|
|
byte[] array2 = vs[num3];
|
|
if (array2 != 0)
|
|
{
|
|
num++;
|
|
throw new ArrayTypeMismatchException();
|
|
}
|
|
num3++;
|
|
}
|
|
byte[] array3 = new byte[num2];
|
|
int num5 = 0;
|
|
if (num > 0)
|
|
{
|
|
byte[] array4 = array[num5];
|
|
int length2 = array4.Length;
|
|
int num6 = 0;
|
|
Array.Copy(array4, num6, array3, num5, length2);
|
|
num5++;
|
|
}
|
|
return array3;
|
|
}
|
|
|
|
// Token: 0x0600983A RID: 38970 RVA: 0x001F5BE8 File Offset: 0x001F3DE8
|
|
[Token(Token = "0x600983A")]
|
|
[Address(RVA = "0x18D2EE0", Offset = "0x18D1CE0", VA = "0x1818D2EE0")]
|
|
public static int[] Concatenate(int[] a, int[] b)
|
|
{
|
|
if (a == 0)
|
|
{
|
|
return Arrays.Clone(b);
|
|
}
|
|
if (b != 0)
|
|
{
|
|
int[] array = new int[b.Length];
|
|
int length = a.Length;
|
|
int num = 0;
|
|
int num2 = 0;
|
|
Array.Copy(a, num2, array, num, length);
|
|
int length2 = b.Length;
|
|
int length3 = a.Length;
|
|
int num3 = 0;
|
|
Array.Copy(b, num3, array, length3, length2);
|
|
return array;
|
|
}
|
|
return Arrays.Clone(a);
|
|
}
|
|
|
|
// Token: 0x0600983B RID: 38971 RVA: 0x001F5C50 File Offset: 0x001F3E50
|
|
[Token(Token = "0x600983B")]
|
|
[Address(RVA = "0x18D3F00", Offset = "0x18D2D00", VA = "0x1818D3F00")]
|
|
public static byte[] Prepend(byte[] a, byte b)
|
|
{
|
|
if (a != 0)
|
|
{
|
|
int length = a.Length;
|
|
byte[] array = new byte[length + 1];
|
|
int num = 0;
|
|
Array.Copy(a, num, array, 1, length);
|
|
array[0] = b;
|
|
return array;
|
|
}
|
|
return new byte[] { b };
|
|
}
|
|
|
|
// Token: 0x0600983C RID: 38972 RVA: 0x001F5CA0 File Offset: 0x001F3EA0
|
|
[Token(Token = "0x600983C")]
|
|
[Address(RVA = "0x18D3FF0", Offset = "0x18D2DF0", VA = "0x1818D3FF0")]
|
|
public static short[] Prepend(short[] a, short b)
|
|
{
|
|
if (a != 0)
|
|
{
|
|
int length = a.Length;
|
|
short[] array = new short[length + 1];
|
|
int num = 0;
|
|
Array.Copy(a, num, array, 1, length);
|
|
array[0] = b;
|
|
return array;
|
|
}
|
|
return new short[] { b };
|
|
}
|
|
|
|
// Token: 0x0600983D RID: 38973 RVA: 0x001F5CF0 File Offset: 0x001F3EF0
|
|
[Token(Token = "0x600983D")]
|
|
[Address(RVA = "0x18D3E10", Offset = "0x18D2C10", VA = "0x1818D3E10")]
|
|
public static int[] Prepend(int[] a, int b)
|
|
{
|
|
if (a != 0)
|
|
{
|
|
int length = a.Length;
|
|
int[] array = new int[length + 1];
|
|
int num = 0;
|
|
Array.Copy(a, num, array, 1, length);
|
|
array[0] = b;
|
|
return array;
|
|
}
|
|
return new int[] { b };
|
|
}
|
|
|
|
// Token: 0x0600983E RID: 38974 RVA: 0x001F5D40 File Offset: 0x001F3F40
|
|
[Token(Token = "0x600983E")]
|
|
[Address(RVA = "0x18D41A0", Offset = "0x18D2FA0", VA = "0x1818D41A0")]
|
|
public static byte[] Reverse(byte[] a)
|
|
{
|
|
if (a != 0)
|
|
{
|
|
int length = a.Length;
|
|
int num = 0;
|
|
byte[] array = new byte[length];
|
|
num++;
|
|
return array;
|
|
}
|
|
throw new IndexOutOfRangeException();
|
|
}
|
|
|
|
// Token: 0x0600983F RID: 38975 RVA: 0x001F5D70 File Offset: 0x001F3F70
|
|
[Token(Token = "0x600983F")]
|
|
[Address(RVA = "0x18D40E0", Offset = "0x18D2EE0", VA = "0x1818D40E0")]
|
|
public static int[] Reverse(int[] a)
|
|
{
|
|
if (a != 0)
|
|
{
|
|
int length = a.Length;
|
|
int num = 0;
|
|
int[] array = new int[length];
|
|
num++;
|
|
int num2 = a[num];
|
|
array[0] = num2;
|
|
return array;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x06009840 RID: 38976 RVA: 0x001F5DB0 File Offset: 0x001F3FB0
|
|
[Token(Token = "0x6009840")]
|
|
[Address(RVA = "0x3F5100", Offset = "0x3F3F00", VA = "0x1803F5100")]
|
|
protected Arrays()
|
|
{
|
|
}
|
|
|
|
// Token: 0x040066E4 RID: 26340
|
|
[Token(Token = "0x40066E4")]
|
|
public static readonly byte[] EmptyBytes = new byte[0];
|
|
|
|
// Token: 0x040066E5 RID: 26341
|
|
[Token(Token = "0x40066E5")]
|
|
public static readonly int[] EmptyInts = new int[0];
|
|
}
|
|
}
|