using System;
using System.Text;
using BestHTTP.SecureProtocol.Org.BouncyCastle.Math;
using Cpp2IlInjected;

namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities
{
	// Token: 0x02001A00 RID: 6656
	[Token(Token = "0x2001A00")]
	public abstract class Arrays
	{
		// Token: 0x06009BD7 RID: 39895 RVA: 0x001FE204 File Offset: 0x001FC404
		[Token(Token = "0x6009BD7")]
		[Address(RVA = "0x4DBE40", Offset = "0x4DAE40", VA = "0x1804DBE40")]
		public static bool AreAllZeroes(byte[] buf, int off, int len)
		{
			int num = 0;
			if (len > 0)
			{
			}
			return num == 0;
		}

		// Token: 0x06009BD8 RID: 39896 RVA: 0x001FE224 File Offset: 0x001FC424
		[Token(Token = "0x6009BD8")]
		[Address(RVA = "0x4DC030", Offset = "0x4DB030", VA = "0x1804DC030")]
		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: 0x06009BD9 RID: 39897 RVA: 0x001FE25C File Offset: 0x001FC45C
		[Token(Token = "0x6009BD9")]
		[Address(RVA = "0x4DBF60", Offset = "0x4DAF60", VA = "0x1804DBF60")]
		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: 0x06009BDA RID: 39898 RVA: 0x001FE2A4 File Offset: 0x001FC4A4
		[Token(Token = "0x6009BDA")]
		[Address(RVA = "0x4DC1B0", Offset = "0x4DB1B0", VA = "0x1804DC1B0")]
		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: 0x06009BDB RID: 39899 RVA: 0x001FE2DC File Offset: 0x001FC4DC
		[Token(Token = "0x6009BDB")]
		[Address(RVA = "0x4DC270", Offset = "0x4DB270", VA = "0x1804DC270")]
		[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: 0x06009BDC RID: 39900 RVA: 0x001FE314 File Offset: 0x001FC514
		[Token(Token = "0x6009BDC")]
		[Address(RVA = "0x4DCB40", Offset = "0x4DBB40", VA = "0x1804DCB40")]
		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: 0x06009BDD RID: 39901 RVA: 0x001FE34C File Offset: 0x001FC54C
		[Token(Token = "0x6009BDD")]
		[Address(RVA = "0x4DC0F0", Offset = "0x4DB0F0", VA = "0x1804DC0F0")]
		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: 0x06009BDE RID: 39902 RVA: 0x001FE394 File Offset: 0x001FC594
		[Token(Token = "0x6009BDE")]
		[Address(RVA = "0x4DBEA0", Offset = "0x4DAEA0", VA = "0x1804DBEA0")]
		[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: 0x06009BDF RID: 39903 RVA: 0x001FE3DC File Offset: 0x001FC5DC
		[Token(Token = "0x6009BDF")]
		[Address(RVA = "0x4DD860", Offset = "0x4DC860", VA = "0x1804DD860")]
		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: 0x06009BE0 RID: 39904 RVA: 0x001FE408 File Offset: 0x001FC608
		[Token(Token = "0x6009BE0")]
		[Address(RVA = "0x4DD8E0", Offset = "0x4DC8E0", VA = "0x1804DD8E0")]
		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: 0x06009BE1 RID: 39905 RVA: 0x001FE43C File Offset: 0x001FC63C
		[Token(Token = "0x6009BE1")]
		[Address(RVA = "0x4DD860", Offset = "0x4DC860", VA = "0x1804DD860")]
		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: 0x06009BE2 RID: 39906 RVA: 0x001FE468 File Offset: 0x001FC668
		[Token(Token = "0x6009BE2")]
		[Address(RVA = "0x4DD7E0", Offset = "0x4DC7E0", VA = "0x1804DD7E0")]
		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: 0x06009BE3 RID: 39907 RVA: 0x001FE49C File Offset: 0x001FC69C
		[Token(Token = "0x6009BE3")]
		[Address(RVA = "0x4DD7E0", Offset = "0x4DC7E0", VA = "0x1804DD7E0")]
		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: 0x06009BE4 RID: 39908 RVA: 0x001FE4D0 File Offset: 0x001FC6D0
		[Token(Token = "0x6009BE4")]
		[Address(RVA = "0x4DDDB0", Offset = "0x4DCDB0", VA = "0x1804DDDB0")]
		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: 0x06009BE5 RID: 39909 RVA: 0x001FE520 File Offset: 0x001FC720
		[Token(Token = "0x6009BE5")]
		[Address(RVA = "0x4DD5F0", Offset = "0x4DC5F0", VA = "0x1804DD5F0")]
		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: 0x06009BE6 RID: 39910 RVA: 0x001FE550 File Offset: 0x001FC750
		[Token(Token = "0x6009BE6")]
		[Address(RVA = "0x4DD590", Offset = "0x4DC590", VA = "0x1804DD590")]
		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: 0x06009BE7 RID: 39911 RVA: 0x001FE57C File Offset: 0x001FC77C
		[Token(Token = "0x6009BE7")]
		[Address(RVA = "0x4DD530", Offset = "0x4DC530", VA = "0x1804DD530")]
		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: 0x06009BE8 RID: 39912 RVA: 0x001FE5A8 File Offset: 0x001FC7A8
		[Token(Token = "0x6009BE8")]
		[Address(RVA = "0x4DD4D0", Offset = "0x4DC4D0", VA = "0x1804DD4D0")]
		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: 0x06009BE9 RID: 39913 RVA: 0x001FE5D0 File Offset: 0x001FC7D0
		[Token(Token = "0x6009BE9")]
		[Address(RVA = "0x4DD530", Offset = "0x4DC530", VA = "0x1804DD530")]
		[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: 0x06009BEA RID: 39914 RVA: 0x001FE600 File Offset: 0x001FC800
		[Token(Token = "0x6009BEA")]
		[Address(RVA = "0x4DD4D0", Offset = "0x4DC4D0", VA = "0x1804DD4D0")]
		[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: 0x06009BEB RID: 39915 RVA: 0x001FE62C File Offset: 0x001FC82C
		[Token(Token = "0x6009BEB")]
		[Address(RVA = "0x4DD650", Offset = "0x4DC650", VA = "0x1804DD650")]
		[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: 0x06009BEC RID: 39916 RVA: 0x001FE65C File Offset: 0x001FC85C
		[Token(Token = "0x6009BEC")]
		[Address(RVA = "0x4DD6C0", Offset = "0x4DC6C0", VA = "0x1804DD6C0")]
		[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: 0x06009BED RID: 39917 RVA: 0x001FE688 File Offset: 0x001FC888
		[Token(Token = "0x6009BED")]
		[Address(RVA = "0x4DC690", Offset = "0x4DB690", VA = "0x1804DC690")]
		public static byte[] Clone(byte[] data)
		{
			while (data != 0)
			{
			}
		}

		// Token: 0x06009BEE RID: 39918 RVA: 0x001FE69C File Offset: 0x001FC89C
		[Token(Token = "0x6009BEE")]
		[Address(RVA = "0x4DC370", Offset = "0x4DB370", VA = "0x1804DC370")]
		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: 0x06009BEF RID: 39919 RVA: 0x001FE6DC File Offset: 0x001FC8DC
		[Token(Token = "0x6009BEF")]
		[Address(RVA = "0x4DC590", Offset = "0x4DB590", VA = "0x1804DC590")]
		public static int[] Clone(int[] data)
		{
			while (data != 0)
			{
			}
			return 0;
		}

		// Token: 0x06009BF0 RID: 39920 RVA: 0x001FE6F0 File Offset: 0x001FC8F0
		[Token(Token = "0x6009BF0")]
		[Address(RVA = "0x4DC710", Offset = "0x4DB710", VA = "0x1804DC710")]
		internal static uint[] Clone(uint[] data)
		{
			while (data != 0)
			{
			}
		}

		// Token: 0x06009BF1 RID: 39921 RVA: 0x001FE704 File Offset: 0x001FC904
		[Token(Token = "0x6009BF1")]
		[Address(RVA = "0x4DC420", Offset = "0x4DB420", VA = "0x1804DC420")]
		public static long[] Clone(long[] data)
		{
			while (data != 0)
			{
			}
		}

		// Token: 0x06009BF2 RID: 39922 RVA: 0x001FE718 File Offset: 0x001FC918
		[Token(Token = "0x6009BF2")]
		[Address(RVA = "0x4DC610", Offset = "0x4DB610", VA = "0x1804DC610")]
		[CLSCompliant(false)]
		public static ulong[] Clone(ulong[] data)
		{
			while (data != 0)
			{
			}
		}

		// Token: 0x06009BF3 RID: 39923 RVA: 0x001FE72C File Offset: 0x001FC92C
		[Token(Token = "0x6009BF3")]
		[Address(RVA = "0x4DC4A0", Offset = "0x4DB4A0", VA = "0x1804DC4A0")]
		[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: 0x06009BF4 RID: 39924 RVA: 0x001FE768 File Offset: 0x001FC968
		[Token(Token = "0x6009BF4")]
		[Address(RVA = "0x4DCC40", Offset = "0x4DBC40", VA = "0x1804DCC40")]
		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: 0x06009BF5 RID: 39925 RVA: 0x001FE790 File Offset: 0x001FC990
		[Token(Token = "0x6009BF5")]
		[Address(RVA = "0x4DCBE0", Offset = "0x4DBBE0", VA = "0x1804DCBE0")]
		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: 0x06009BF6 RID: 39926 RVA: 0x001FE7C0 File Offset: 0x001FC9C0
		[Token(Token = "0x6009BF6")]
		[Address(RVA = "0x4DCCA0", Offset = "0x4DBCA0", VA = "0x1804DCCA0")]
		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: 0x06009BF7 RID: 39927 RVA: 0x001FE7F0 File Offset: 0x001FC9F0
		[Token(Token = "0x6009BF7")]
		[Address(RVA = "0x4DD480", Offset = "0x4DC480", VA = "0x1804DD480")]
		public static void Fill(byte[] buf, byte b)
		{
			int num = buf.Length;
			if (num > 0)
			{
				num--;
			}
		}

		// Token: 0x06009BF8 RID: 39928 RVA: 0x001FE814 File Offset: 0x001FCA14
		[Token(Token = "0x6009BF8")]
		[Address(RVA = "0x4DD430", Offset = "0x4DC430", VA = "0x1804DD430")]
		public static void Fill(byte[] buf, int from, int to, byte b)
		{
			if (from < to)
			{
			}
		}

		// Token: 0x06009BF9 RID: 39929 RVA: 0x001FE82C File Offset: 0x001FCA2C
		[Token(Token = "0x6009BF9")]
		[Address(RVA = "0x4DD2D0", Offset = "0x4DC2D0", VA = "0x1804DD2D0")]
		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: 0x06009BFA RID: 39930 RVA: 0x001FE868 File Offset: 0x001FCA68
		[Token(Token = "0x6009BFA")]
		[Address(RVA = "0x4DD170", Offset = "0x4DC170", VA = "0x1804DD170")]
		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: 0x06009BFB RID: 39931 RVA: 0x001FE8A4 File Offset: 0x001FCAA4
		[Token(Token = "0x6009BFB")]
		[Address(RVA = "0x4DD380", Offset = "0x4DC380", VA = "0x1804DD380")]
		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: 0x06009BFC RID: 39932 RVA: 0x001FE8E0 File Offset: 0x001FCAE0
		[Token(Token = "0x6009BFC")]
		[Address(RVA = "0x4DD220", Offset = "0x4DC220", VA = "0x1804DD220")]
		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: 0x06009BFD RID: 39933 RVA: 0x001FE91C File Offset: 0x001FCB1C
		[Token(Token = "0x6009BFD")]
		[Address(RVA = "0x4DD0C0", Offset = "0x4DC0C0", VA = "0x1804DD0C0")]
		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: 0x06009BFE RID: 39934 RVA: 0x001FE958 File Offset: 0x001FCB58
		[Token(Token = "0x6009BFE")]
		[Address(RVA = "0x4DCDF0", Offset = "0x4DBDF0", VA = "0x1804DCDF0")]
		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: 0x06009BFF RID: 39935 RVA: 0x001FE9A0 File Offset: 0x001FCBA0
		[Token(Token = "0x6009BFF")]
		[Address(RVA = "0x4DCEE0", Offset = "0x4DBEE0", VA = "0x1804DCEE0")]
		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: 0x06009C00 RID: 39936 RVA: 0x001FE9E8 File Offset: 0x001FCBE8
		[Token(Token = "0x6009C00")]
		[Address(RVA = "0x4DCD00", Offset = "0x4DBD00", VA = "0x1804DCD00")]
		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: 0x06009C01 RID: 39937 RVA: 0x001FEA30 File Offset: 0x001FCC30
		[Token(Token = "0x6009C01")]
		[Address(RVA = "0x4DCFD0", Offset = "0x4DBFD0", VA = "0x1804DCFD0")]
		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: 0x06009C02 RID: 39938 RVA: 0x001FEA78 File Offset: 0x001FCC78
		[Token(Token = "0x6009C02")]
		[Address(RVA = "0x4DD730", Offset = "0x4DC730", VA = "0x1804DD730")]
		private static int GetLength(int from, int to)
		{
			return to;
		}

		// Token: 0x06009C03 RID: 39939 RVA: 0x001FEA98 File Offset: 0x001FCC98
		[Token(Token = "0x6009C03")]
		[Address(RVA = "0x4DBD60", Offset = "0x4DAD60", VA = "0x1804DBD60")]
		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: 0x06009C04 RID: 39940 RVA: 0x001FEAE0 File Offset: 0x001FCCE0
		[Token(Token = "0x6009C04")]
		[Address(RVA = "0x4DBBA0", Offset = "0x4DABA0", VA = "0x1804DBBA0")]
		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: 0x06009C05 RID: 39941 RVA: 0x001FEB30 File Offset: 0x001FCD30
		[Token(Token = "0x6009C05")]
		[Address(RVA = "0x4DBC80", Offset = "0x4DAC80", VA = "0x1804DBC80")]
		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: 0x06009C06 RID: 39942 RVA: 0x001FEB80 File Offset: 0x001FCD80
		[Token(Token = "0x6009C06")]
		[Address(RVA = "0x4DC920", Offset = "0x4DB920", VA = "0x1804DC920")]
		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: 0x06009C07 RID: 39943 RVA: 0x001FEBE8 File Offset: 0x001FCDE8
		[Token(Token = "0x6009C07")]
		[Address(RVA = "0x4DC790", Offset = "0x4DB790", VA = "0x1804DC790")]
		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: 0x06009C08 RID: 39944 RVA: 0x001FEC80 File Offset: 0x001FCE80
		[Token(Token = "0x6009C08")]
		[Address(RVA = "0x4DCA30", Offset = "0x4DBA30", VA = "0x1804DCA30")]
		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: 0x06009C09 RID: 39945 RVA: 0x001FECE8 File Offset: 0x001FCEE8
		[Token(Token = "0x6009C09")]
		[Address(RVA = "0x4DDA50", Offset = "0x4DCA50", VA = "0x1804DDA50")]
		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: 0x06009C0A RID: 39946 RVA: 0x001FED38 File Offset: 0x001FCF38
		[Token(Token = "0x6009C0A")]
		[Address(RVA = "0x4DDB40", Offset = "0x4DCB40", VA = "0x1804DDB40")]
		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: 0x06009C0B RID: 39947 RVA: 0x001FED88 File Offset: 0x001FCF88
		[Token(Token = "0x6009C0B")]
		[Address(RVA = "0x4DD960", Offset = "0x4DC960", VA = "0x1804DD960")]
		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: 0x06009C0C RID: 39948 RVA: 0x001FEDD8 File Offset: 0x001FCFD8
		[Token(Token = "0x6009C0C")]
		[Address(RVA = "0x4DDCF0", Offset = "0x4DCCF0", VA = "0x1804DDCF0")]
		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: 0x06009C0D RID: 39949 RVA: 0x001FEE08 File Offset: 0x001FD008
		[Token(Token = "0x6009C0D")]
		[Address(RVA = "0x4DDC30", Offset = "0x4DCC30", VA = "0x1804DDC30")]
		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: 0x06009C0E RID: 39950 RVA: 0x001FEE48 File Offset: 0x001FD048
		[Token(Token = "0x6009C0E")]
		[Address(RVA = "0x412370", Offset = "0x411370", VA = "0x180412370")]
		protected Arrays()
		{
		}

		// Token: 0x0400689D RID: 26781
		[Token(Token = "0x400689D")]
		public static readonly byte[] EmptyBytes = new byte[0];

		// Token: 0x0400689E RID: 26782
		[Token(Token = "0x400689E")]
		public static readonly int[] EmptyInts = new int[0];
	}
}