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