niko
955 lines
24 KiB
C#
955 lines
24 KiB
C#
using System;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using BestHTTP.SecureProtocol.Org.BouncyCastle.Math;
|
|
using Cpp2IlInjected;
|
|
|
|
namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities
|
|
{
|
|
// Token: 0x02001343 RID: 4931
|
|
[Token(Token = "0x2001343")]
|
|
[StructLayout(3)]
|
|
public abstract class Arrays
|
|
{
|
|
// Token: 0x06007C2F RID: 31791 RVA: 0x0019D7A8 File Offset: 0x0019B9A8
|
|
[Token(Token = "0x6007C2F")]
|
|
[Address(RVA = "0x1C59E80", Offset = "0x1C58880", VA = "0x181C59E80")]
|
|
public static bool AreAllZeroes(byte[] buf, int off, int len)
|
|
{
|
|
int num = 0;
|
|
if (len > 0)
|
|
{
|
|
}
|
|
return num == 0;
|
|
}
|
|
|
|
// Token: 0x06007C30 RID: 31792 RVA: 0x0019D7C8 File Offset: 0x0019B9C8
|
|
[Token(Token = "0x6007C30")]
|
|
[Address(RVA = "0x1C5A070", Offset = "0x1C58A70", VA = "0x181C5A070")]
|
|
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: 0x06007C31 RID: 31793 RVA: 0x0019D800 File Offset: 0x0019BA00
|
|
[Token(Token = "0x6007C31")]
|
|
[Address(RVA = "0x1C59FA0", Offset = "0x1C589A0", VA = "0x181C59FA0")]
|
|
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: 0x06007C32 RID: 31794 RVA: 0x0019D848 File Offset: 0x0019BA48
|
|
[Token(Token = "0x6007C32")]
|
|
[Address(RVA = "0x1C5A1F0", Offset = "0x1C58BF0", VA = "0x181C5A1F0")]
|
|
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: 0x06007C33 RID: 31795 RVA: 0x0019D880 File Offset: 0x0019BA80
|
|
[Token(Token = "0x6007C33")]
|
|
[Address(RVA = "0x1C5A2B0", Offset = "0x1C58CB0", VA = "0x181C5A2B0")]
|
|
[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: 0x06007C34 RID: 31796 RVA: 0x0019D8B8 File Offset: 0x0019BAB8
|
|
[Token(Token = "0x6007C34")]
|
|
[Address(RVA = "0x1C5AB80", Offset = "0x1C59580", VA = "0x181C5AB80")]
|
|
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: 0x06007C35 RID: 31797 RVA: 0x0019D8F0 File Offset: 0x0019BAF0
|
|
[Token(Token = "0x6007C35")]
|
|
[Address(RVA = "0x1C5A130", Offset = "0x1C58B30", VA = "0x181C5A130")]
|
|
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: 0x06007C36 RID: 31798 RVA: 0x0019D938 File Offset: 0x0019BB38
|
|
[Token(Token = "0x6007C36")]
|
|
[Address(RVA = "0x1C59EE0", Offset = "0x1C588E0", VA = "0x181C59EE0")]
|
|
[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: 0x06007C37 RID: 31799 RVA: 0x0019D980 File Offset: 0x0019BB80
|
|
[Token(Token = "0x6007C37")]
|
|
[Address(RVA = "0x1C5B8A0", Offset = "0x1C5A2A0", VA = "0x181C5B8A0")]
|
|
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: 0x06007C38 RID: 31800 RVA: 0x0019D9AC File Offset: 0x0019BBAC
|
|
[Token(Token = "0x6007C38")]
|
|
[Address(RVA = "0x1C5B920", Offset = "0x1C5A320", VA = "0x181C5B920")]
|
|
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: 0x06007C39 RID: 31801 RVA: 0x0019D9E0 File Offset: 0x0019BBE0
|
|
[Token(Token = "0x6007C39")]
|
|
[Address(RVA = "0x1C5B8A0", Offset = "0x1C5A2A0", VA = "0x181C5B8A0")]
|
|
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: 0x06007C3A RID: 31802 RVA: 0x0019DA0C File Offset: 0x0019BC0C
|
|
[Token(Token = "0x6007C3A")]
|
|
[Address(RVA = "0x1C5B820", Offset = "0x1C5A220", VA = "0x181C5B820")]
|
|
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: 0x06007C3B RID: 31803 RVA: 0x0019DA40 File Offset: 0x0019BC40
|
|
[Token(Token = "0x6007C3B")]
|
|
[Address(RVA = "0x1C5B820", Offset = "0x1C5A220", VA = "0x181C5B820")]
|
|
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: 0x06007C3C RID: 31804 RVA: 0x0019DA74 File Offset: 0x0019BC74
|
|
[Token(Token = "0x6007C3C")]
|
|
[Address(RVA = "0x1C5BDF0", Offset = "0x1C5A7F0", VA = "0x181C5BDF0")]
|
|
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: 0x06007C3D RID: 31805 RVA: 0x0019DAC4 File Offset: 0x0019BCC4
|
|
[Token(Token = "0x6007C3D")]
|
|
[Address(RVA = "0x1C5B630", Offset = "0x1C5A030", VA = "0x181C5B630")]
|
|
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: 0x06007C3E RID: 31806 RVA: 0x0019DAF4 File Offset: 0x0019BCF4
|
|
[Token(Token = "0x6007C3E")]
|
|
[Address(RVA = "0x1C5B5D0", Offset = "0x1C59FD0", VA = "0x181C5B5D0")]
|
|
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: 0x06007C3F RID: 31807 RVA: 0x0019DB20 File Offset: 0x0019BD20
|
|
[Token(Token = "0x6007C3F")]
|
|
[Address(RVA = "0x1C5B570", Offset = "0x1C59F70", VA = "0x181C5B570")]
|
|
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: 0x06007C40 RID: 31808 RVA: 0x0019DB4C File Offset: 0x0019BD4C
|
|
[Token(Token = "0x6007C40")]
|
|
[Address(RVA = "0x1C5B510", Offset = "0x1C59F10", VA = "0x181C5B510")]
|
|
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: 0x06007C41 RID: 31809 RVA: 0x0019DB74 File Offset: 0x0019BD74
|
|
[Token(Token = "0x6007C41")]
|
|
[Address(RVA = "0x1C5B570", Offset = "0x1C59F70", VA = "0x181C5B570")]
|
|
[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: 0x06007C42 RID: 31810 RVA: 0x0019DBA4 File Offset: 0x0019BDA4
|
|
[Token(Token = "0x6007C42")]
|
|
[Address(RVA = "0x1C5B510", Offset = "0x1C59F10", VA = "0x181C5B510")]
|
|
[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: 0x06007C43 RID: 31811 RVA: 0x0019DBD0 File Offset: 0x0019BDD0
|
|
[Token(Token = "0x6007C43")]
|
|
[Address(RVA = "0x1C5B690", Offset = "0x1C5A090", VA = "0x181C5B690")]
|
|
[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: 0x06007C44 RID: 31812 RVA: 0x0019DC00 File Offset: 0x0019BE00
|
|
[Token(Token = "0x6007C44")]
|
|
[Address(RVA = "0x1C5B700", Offset = "0x1C5A100", VA = "0x181C5B700")]
|
|
[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: 0x06007C45 RID: 31813 RVA: 0x0019DC2C File Offset: 0x0019BE2C
|
|
[Token(Token = "0x6007C45")]
|
|
[Address(RVA = "0x1C5A6D0", Offset = "0x1C590D0", VA = "0x181C5A6D0")]
|
|
public static byte[] Clone(byte[] data)
|
|
{
|
|
while (data != 0)
|
|
{
|
|
}
|
|
}
|
|
|
|
// Token: 0x06007C46 RID: 31814 RVA: 0x0019DC40 File Offset: 0x0019BE40
|
|
[Token(Token = "0x6007C46")]
|
|
[Address(RVA = "0x1C5A3B0", Offset = "0x1C58DB0", VA = "0x181C5A3B0")]
|
|
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: 0x06007C47 RID: 31815 RVA: 0x0019DC80 File Offset: 0x0019BE80
|
|
[Token(Token = "0x6007C47")]
|
|
[Address(RVA = "0x1C5A5D0", Offset = "0x1C58FD0", VA = "0x181C5A5D0")]
|
|
public static int[] Clone(int[] data)
|
|
{
|
|
while (data != 0)
|
|
{
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Token: 0x06007C48 RID: 31816 RVA: 0x0019DC94 File Offset: 0x0019BE94
|
|
[Token(Token = "0x6007C48")]
|
|
[Address(RVA = "0x1C5A750", Offset = "0x1C59150", VA = "0x181C5A750")]
|
|
internal static uint[] Clone(uint[] data)
|
|
{
|
|
while (data != 0)
|
|
{
|
|
}
|
|
}
|
|
|
|
// Token: 0x06007C49 RID: 31817 RVA: 0x0019DCA8 File Offset: 0x0019BEA8
|
|
[Token(Token = "0x6007C49")]
|
|
[Address(RVA = "0x1C5A460", Offset = "0x1C58E60", VA = "0x181C5A460")]
|
|
public static long[] Clone(long[] data)
|
|
{
|
|
while (data != 0)
|
|
{
|
|
}
|
|
}
|
|
|
|
// Token: 0x06007C4A RID: 31818 RVA: 0x0019DCBC File Offset: 0x0019BEBC
|
|
[Token(Token = "0x6007C4A")]
|
|
[Address(RVA = "0x1C5A650", Offset = "0x1C59050", VA = "0x181C5A650")]
|
|
[CLSCompliant(false)]
|
|
public static ulong[] Clone(ulong[] data)
|
|
{
|
|
while (data != 0)
|
|
{
|
|
}
|
|
}
|
|
|
|
// Token: 0x06007C4B RID: 31819 RVA: 0x0019DCD0 File Offset: 0x0019BED0
|
|
[Token(Token = "0x6007C4B")]
|
|
[Address(RVA = "0x1C5A4E0", Offset = "0x1C58EE0", VA = "0x181C5A4E0")]
|
|
[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: 0x06007C4C RID: 31820 RVA: 0x0019DD0C File Offset: 0x0019BF0C
|
|
[Token(Token = "0x6007C4C")]
|
|
[Address(RVA = "0x1C5AC80", Offset = "0x1C59680", VA = "0x181C5AC80")]
|
|
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: 0x06007C4D RID: 31821 RVA: 0x0019DD34 File Offset: 0x0019BF34
|
|
[Token(Token = "0x6007C4D")]
|
|
[Address(RVA = "0x1C5AC20", Offset = "0x1C59620", VA = "0x181C5AC20")]
|
|
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: 0x06007C4E RID: 31822 RVA: 0x0019DD64 File Offset: 0x0019BF64
|
|
[Token(Token = "0x6007C4E")]
|
|
[Address(RVA = "0x1C5ACE0", Offset = "0x1C596E0", VA = "0x181C5ACE0")]
|
|
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: 0x06007C4F RID: 31823 RVA: 0x0019DD94 File Offset: 0x0019BF94
|
|
[Token(Token = "0x6007C4F")]
|
|
[Address(RVA = "0x1C5B4C0", Offset = "0x1C59EC0", VA = "0x181C5B4C0")]
|
|
public static void Fill(byte[] buf, byte b)
|
|
{
|
|
int num = buf.Length;
|
|
if (num > 0)
|
|
{
|
|
num--;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06007C50 RID: 31824 RVA: 0x0019DDB8 File Offset: 0x0019BFB8
|
|
[Token(Token = "0x6007C50")]
|
|
[Address(RVA = "0x1C5B470", Offset = "0x1C59E70", VA = "0x181C5B470")]
|
|
public static void Fill(byte[] buf, int from, int to, byte b)
|
|
{
|
|
if (from < to)
|
|
{
|
|
}
|
|
}
|
|
|
|
// Token: 0x06007C51 RID: 31825 RVA: 0x0019DDD0 File Offset: 0x0019BFD0
|
|
[Token(Token = "0x6007C51")]
|
|
[Address(RVA = "0x1C5B310", Offset = "0x1C59D10", VA = "0x181C5B310")]
|
|
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: 0x06007C52 RID: 31826 RVA: 0x0019DE0C File Offset: 0x0019C00C
|
|
[Token(Token = "0x6007C52")]
|
|
[Address(RVA = "0x1C5B1B0", Offset = "0x1C59BB0", VA = "0x181C5B1B0")]
|
|
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: 0x06007C53 RID: 31827 RVA: 0x0019DE48 File Offset: 0x0019C048
|
|
[Token(Token = "0x6007C53")]
|
|
[Address(RVA = "0x1C5B3C0", Offset = "0x1C59DC0", VA = "0x181C5B3C0")]
|
|
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: 0x06007C54 RID: 31828 RVA: 0x0019DE84 File Offset: 0x0019C084
|
|
[Token(Token = "0x6007C54")]
|
|
[Address(RVA = "0x1C5B260", Offset = "0x1C59C60", VA = "0x181C5B260")]
|
|
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: 0x06007C55 RID: 31829 RVA: 0x0019DEC0 File Offset: 0x0019C0C0
|
|
[Token(Token = "0x6007C55")]
|
|
[Address(RVA = "0x1C5B100", Offset = "0x1C59B00", VA = "0x181C5B100")]
|
|
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: 0x06007C56 RID: 31830 RVA: 0x0019DEFC File Offset: 0x0019C0FC
|
|
[Token(Token = "0x6007C56")]
|
|
[Address(RVA = "0x1C5AE30", Offset = "0x1C59830", VA = "0x181C5AE30")]
|
|
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: 0x06007C57 RID: 31831 RVA: 0x0019DF44 File Offset: 0x0019C144
|
|
[Token(Token = "0x6007C57")]
|
|
[Address(RVA = "0x1C5AF20", Offset = "0x1C59920", VA = "0x181C5AF20")]
|
|
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: 0x06007C58 RID: 31832 RVA: 0x0019DF8C File Offset: 0x0019C18C
|
|
[Token(Token = "0x6007C58")]
|
|
[Address(RVA = "0x1C5AD40", Offset = "0x1C59740", VA = "0x181C5AD40")]
|
|
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: 0x06007C59 RID: 31833 RVA: 0x0019DFD4 File Offset: 0x0019C1D4
|
|
[Token(Token = "0x6007C59")]
|
|
[Address(RVA = "0x1C5B010", Offset = "0x1C59A10", VA = "0x181C5B010")]
|
|
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: 0x06007C5A RID: 31834 RVA: 0x0019E01C File Offset: 0x0019C21C
|
|
[Token(Token = "0x6007C5A")]
|
|
[Address(RVA = "0x1C5B770", Offset = "0x1C5A170", VA = "0x181C5B770")]
|
|
private static int GetLength(int from, int to)
|
|
{
|
|
return to;
|
|
}
|
|
|
|
// Token: 0x06007C5B RID: 31835 RVA: 0x0019E03C File Offset: 0x0019C23C
|
|
[Token(Token = "0x6007C5B")]
|
|
[Address(RVA = "0x1C59DA0", Offset = "0x1C587A0", VA = "0x181C59DA0")]
|
|
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: 0x06007C5C RID: 31836 RVA: 0x0019E084 File Offset: 0x0019C284
|
|
[Token(Token = "0x6007C5C")]
|
|
[Address(RVA = "0x1C59BE0", Offset = "0x1C585E0", VA = "0x181C59BE0")]
|
|
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: 0x06007C5D RID: 31837 RVA: 0x0019E0D4 File Offset: 0x0019C2D4
|
|
[Token(Token = "0x6007C5D")]
|
|
[Address(RVA = "0x1C59CC0", Offset = "0x1C586C0", VA = "0x181C59CC0")]
|
|
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: 0x06007C5E RID: 31838 RVA: 0x0019E124 File Offset: 0x0019C324
|
|
[Token(Token = "0x6007C5E")]
|
|
[Address(RVA = "0x1C5A960", Offset = "0x1C59360", VA = "0x181C5A960")]
|
|
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: 0x06007C5F RID: 31839 RVA: 0x0019E18C File Offset: 0x0019C38C
|
|
[Token(Token = "0x6007C5F")]
|
|
[Address(RVA = "0x1C5A7D0", Offset = "0x1C591D0", VA = "0x181C5A7D0")]
|
|
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: 0x06007C60 RID: 31840 RVA: 0x0019E224 File Offset: 0x0019C424
|
|
[Token(Token = "0x6007C60")]
|
|
[Address(RVA = "0x1C5AA70", Offset = "0x1C59470", VA = "0x181C5AA70")]
|
|
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: 0x06007C61 RID: 31841 RVA: 0x0019E28C File Offset: 0x0019C48C
|
|
[Token(Token = "0x6007C61")]
|
|
[Address(RVA = "0x1C5BA90", Offset = "0x1C5A490", VA = "0x181C5BA90")]
|
|
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: 0x06007C62 RID: 31842 RVA: 0x0019E2DC File Offset: 0x0019C4DC
|
|
[Token(Token = "0x6007C62")]
|
|
[Address(RVA = "0x1C5BB80", Offset = "0x1C5A580", VA = "0x181C5BB80")]
|
|
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: 0x06007C63 RID: 31843 RVA: 0x0019E32C File Offset: 0x0019C52C
|
|
[Token(Token = "0x6007C63")]
|
|
[Address(RVA = "0x1C5B9A0", Offset = "0x1C5A3A0", VA = "0x181C5B9A0")]
|
|
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: 0x06007C64 RID: 31844 RVA: 0x0019E37C File Offset: 0x0019C57C
|
|
[Token(Token = "0x6007C64")]
|
|
[Address(RVA = "0x1C5BD30", Offset = "0x1C5A730", VA = "0x181C5BD30")]
|
|
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: 0x06007C65 RID: 31845 RVA: 0x0019E3AC File Offset: 0x0019C5AC
|
|
[Token(Token = "0x6007C65")]
|
|
[Address(RVA = "0x1C5BC70", Offset = "0x1C5A670", VA = "0x181C5BC70")]
|
|
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: 0x06007C66 RID: 31846 RVA: 0x0019E3EC File Offset: 0x0019C5EC
|
|
[Token(Token = "0x6007C66")]
|
|
[Address(RVA = "0x3C1670", Offset = "0x3C0070", VA = "0x1803C1670")]
|
|
protected Arrays()
|
|
{
|
|
}
|
|
|
|
// Token: 0x040058A1 RID: 22689
|
|
[Token(Token = "0x40058A1")]
|
|
public static readonly byte[] EmptyBytes = new byte[0];
|
|
|
|
// Token: 0x040058A2 RID: 22690
|
|
[Token(Token = "0x40058A2")]
|
|
public static readonly int[] EmptyInts = new int[0];
|
|
}
|
|
}
|