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];
	}
}