Jan2021-Cpp2Il-Dump/Assembly-CSharp/BestHTTP/SecureProtocol/Org/BouncyCastle/Utilities/Zlib/Deflate.cs

using System;
using System.Runtime.InteropServices;
using Cpp2IlInjected;

namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.Zlib
{
	// Token: 0x0200134D RID: 4941
	[Token(Token = "0x200134D")]
	[StructLayout(3)]
	public sealed class Deflate
	{
		// Token: 0x06007CA0 RID: 31904 RVA: 0x0019EC5C File Offset: 0x0019CE5C
		[Token(Token = "0x6007CA0")]
		[Address(RVA = "0x20254C0", Offset = "0x2023EC0", VA = "0x1820254C0")]
		static Deflate()
		{
			string[] array = new string[10];
			if ("need dictionary" != 0)
			{
			}
			array[0] = "need dictionary";
			if ("stream end" != 0)
			{
			}
			array[1] = "stream end";
			if ("" != 0)
			{
			}
			array[2] = "";
			if ("file error" != 0)
			{
			}
			array[3] = "file error";
			if ("stream error" != 0)
			{
			}
			array[4] = "stream error";
			if ("data error" != 0)
			{
			}
			array[5] = "data error";
			if ("insufficient memory" != 0)
			{
			}
			array[6] = "insufficient memory";
			if ("buffer error" != 0)
			{
			}
			array[7] = "buffer error";
			if ("incompatible version" != 0)
			{
			}
			array[8] = "incompatible version";
			if ("" != 0)
			{
			}
			array[9] = "";
			Deflate.z_errmsg = array;
			Deflate.config_table = new Deflate.Config[10];
			Deflate.Config[] array2 = Deflate.config_table;
			int num = 0;
			Deflate.Config config;
			config.good_length = num;
			config.nice_length = num;
			config.func = num;
			array2[0] = config;
			Deflate.Config[] array3 = Deflate.config_table;
			Deflate.Config config2;
			config2.good_length = (int)((ulong)4L);
			config2.max_lazy = (int)((ulong)4L);
			config2.nice_length = (int)((ulong)8L);
			config2.max_chain = (int)((ulong)4L);
			config2.func = (int)((ulong)1L);
			array3[1] = config2;
			Deflate.Config[] array4 = Deflate.config_table;
			Deflate.Config config3;
			config3.good_length = (int)((ulong)4L);
			config3.max_lazy = (int)((ulong)5L);
			config3.nice_length = (int)((ulong)16L);
			config3.max_chain = (int)((ulong)8L);
			config3.func = (int)((ulong)1L);
			array4[2] = config3;
			Deflate.Config[] array5 = Deflate.config_table;
			Deflate.Config config4;
			config4.good_length = (int)((ulong)4L);
			config4.max_lazy = (int)((ulong)6L);
			config4.nice_length = (int)((ulong)32L);
			config4.max_chain = (int)((ulong)32L);
			config4.func = (int)((ulong)1L);
			array5[3] = config4;
			Deflate.Config[] array6 = Deflate.config_table;
			Deflate.Config config5;
			config5.good_length = (int)((ulong)4L);
			config5.max_lazy = (int)((ulong)4L);
			config5.nice_length = (int)((ulong)16L);
			config5.max_chain = (int)((ulong)16L);
			config5.func = (int)((ulong)2L);
			array6[4] = config5;
			Deflate.Config[] array7 = Deflate.config_table;
			Deflate.Config config6;
			config6.good_length = (int)((ulong)8L);
			config6.max_lazy = (int)((ulong)16L);
			config6.nice_length = (int)((ulong)32L);
			config6.max_chain = (int)((ulong)32L);
			config6.func = (int)((ulong)2L);
			array7[5] = config6;
			Deflate.Config[] array8 = Deflate.config_table;
			Deflate.Config config7;
			config7.good_length = (int)((ulong)8L);
			config7.max_lazy = (int)((ulong)16L);
			config7.nice_length = (int)((ulong)128L);
			config7.max_chain = (int)((ulong)128L);
			config7.func = (int)((ulong)2L);
			array8[6] = config7;
			Deflate.Config[] array9 = Deflate.config_table;
			Deflate.Config config8;
			config8.good_length = (int)((ulong)8L);
			config8.max_lazy = (int)((ulong)32L);
			config8.nice_length = (int)((ulong)128L);
			config8.max_chain = (int)((ulong)256L);
			config8.func = (int)((ulong)2L);
			array9[7] = config8;
			Deflate.Config[] array10 = Deflate.config_table;
			Deflate.Config config9;
			config9.good_length = (int)((ulong)32L);
			config9.max_lazy = (int)((ulong)128L);
			config9.nice_length = (int)((ulong)258L);
			config9.max_chain = (int)((ulong)1024L);
			config9.func = (int)((ulong)2L);
			array10[8] = config9;
			Deflate.Config[] array11 = Deflate.config_table;
			Deflate.Config config10;
			config10.good_length = (int)((ulong)32L);
			config10.max_lazy = (int)((ulong)258L);
			config10.nice_length = (int)((ulong)258L);
			config10.max_chain = (int)((ulong)4096L);
			config10.func = (int)((ulong)2L);
			array11[9] = config10;
		}

		// Token: 0x06007CA1 RID: 31905 RVA: 0x0019F008 File Offset: 0x0019D208
		[Token(Token = "0x6007CA1")]
		[Address(RVA = "0x2025EC0", Offset = "0x20248C0", VA = "0x182025EC0")]
		internal Deflate()
		{
			ZTree ztree = new ZTree();
			this.l_desc = ztree;
			ZTree ztree2 = new ZTree();
			this.d_desc = ztree2;
			ZTree ztree3 = new ZTree();
			this.bl_desc = ztree3;
			short[] array = new short[16];
			this.bl_count = array;
			int[] array2 = new int[573];
			this.heap = array2;
			byte[] array3 = new byte[573];
			this.depth = array3;
			base..ctor();
			short[] array4 = new short[1146];
			this.dyn_ltree = array4;
			short[] array5 = new short[122];
			this.dyn_dtree = array5;
			short[] array6 = new short[78];
			this.bl_tree = array6;
		}

		// Token: 0x06007CA2 RID: 31906 RVA: 0x0019F0B0 File Offset: 0x0019D2B0
		[Token(Token = "0x6007CA2")]
		[Address(RVA = "0x2029350", Offset = "0x2027D50", VA = "0x182029350")]
		internal void lm_init()
		{
			int num = this.w_size;
			short[] array = this.head;
			num += num;
			this.window_size = num;
			int num2 = this.hash_size;
			int num3 = 0;
			array[0] = (short)num3;
			if (this.hash_size > 0)
			{
				short[] array2 = this.head;
				num3++;
				array2[0] = (short)num3;
				int num4 = this.hash_size;
			}
			Deflate.Config[] array3 = Deflate.config_table;
			int num5 = this.level;
			int max_lazy = array3[num5].max_lazy;
			this.max_lazy_match = max_lazy;
			int good_length = Deflate.config_table[num5].good_length;
			this.good_match = good_length;
			int nice_length = Deflate.config_table[num5].nice_length;
			this.nice_match = nice_length;
			int max_chain = Deflate.config_table[num5].max_chain;
			this.match_available = num3;
			this.block_start = num3;
			this.lookahead = num3;
			this.ins_h = num3;
			this.max_chain_length = max_chain;
			this.prev_length = (int)((ulong)2L);
			this.match_length = (int)((ulong)2L);
		}

		// Token: 0x06007CA3 RID: 31907 RVA: 0x0019F1BC File Offset: 0x0019D3BC
		[Token(Token = "0x6007CA3")]
		[Address(RVA = "0x202A890", Offset = "0x2029290", VA = "0x18202A890")]
		internal void tr_init()
		{
			ZTree ztree = this.l_desc;
			short[] array = this.dyn_ltree;
			ztree.dyn_tree = array;
			ZTree ztree2 = this.l_desc;
			StaticTree static_l_desc = StaticTree.static_l_desc;
			ztree2.stat_desc = static_l_desc;
			ZTree ztree3 = this.d_desc;
			short[] array2 = this.dyn_dtree;
			ztree3.dyn_tree = array2;
			ZTree ztree4 = this.d_desc;
			StaticTree static_d_desc = StaticTree.static_d_desc;
			ztree4.stat_desc = static_d_desc;
			ZTree ztree5 = this.bl_desc;
			short[] array3 = this.bl_tree;
			ztree5.dyn_tree = array3;
			ZTree ztree6 = this.bl_desc;
			StaticTree static_bl_desc = StaticTree.static_bl_desc;
			ztree6.stat_desc = static_bl_desc;
			int num = 0;
			this.bi_buf = (uint)num;
			this.last_eob_len = (int)((ulong)8L);
			this.init_block();
		}

		// Token: 0x06007CA4 RID: 31908 RVA: 0x0019F274 File Offset: 0x0019D474
		[Token(Token = "0x6007CA4")]
		[Address(RVA = "0x2029220", Offset = "0x2027C20", VA = "0x182029220")]
		internal void init_block()
		{
			int num = 0;
			short[] array = this.dyn_ltree;
			num += 2;
			array[0] = (short)num;
			short[] array2 = this.dyn_dtree;
			num += 2;
			array2[0] = (short)num;
			short[] array3 = this.bl_tree;
			num += 2;
			array3[0] = (short)num;
			uint num2;
			this.dyn_ltree[128] = (short)num2;
			this.opt_len = num;
			this.matches = num;
			this.last_lit = num;
		}

		// Token: 0x06007CA5 RID: 31909 RVA: 0x0019F2EC File Offset: 0x0019D4EC
		[Token(Token = "0x6007CA5")]
		[Address(RVA = "0x2029BA0", Offset = "0x20285A0", VA = "0x182029BA0")]
		internal void pqdownheap(short[] tree, int k)
		{
			int[] array = this.heap;
			int num = this.heap_len;
			int num2 = array[k];
			int length = this.heap.Length;
			int num3 = k + 1;
			byte[] array2 = this.depth;
			if (Deflate.smaller(tree, num3, k, array2))
			{
			}
			int[] array3 = this.heap;
			byte[] array4 = this.depth;
			if (!Deflate.smaller(tree, num2, k, array4))
			{
				int[] array5 = this.heap;
				int length2 = array5.Length;
				int num4;
				array5[0] = num4;
				int num5 = this.heap_len;
			}
			int[] array6 = this.heap;
			array6[0] = num2;
		}

		// Token: 0x06007CA6 RID: 31910 RVA: 0x0019F390 File Offset: 0x0019D590
		[Token(Token = "0x6007CA6")]
		[Address(RVA = "0x202A7D0", Offset = "0x20291D0", VA = "0x18202A7D0")]
		internal static bool smaller(short[] tree, int n, int m, byte[] depth)
		{
			int length = tree.Length;
			short num;
			short num2;
			if (num < num2)
			{
				return true;
			}
			if (num != num2)
			{
			}
			int length2 = depth.Length;
			throw new NullReferenceException();
		}

		// Token: 0x06007CA7 RID: 31911 RVA: 0x0019F3C0 File Offset: 0x0019D5C0
		[Token(Token = "0x6007CA7")]
		[Address(RVA = "0x2029F90", Offset = "0x2028990", VA = "0x182029F90")]
		internal void scan_tree(short[] tree, int max_code)
		{
			int length = tree.Length;
			int i = 0;
			uint num;
			tree[0] = (short)num;
			int num2 = 0;
			num2 += 3;
			uint num3;
			if (1U < num3)
			{
			}
			if (tree == 0)
			{
				short[] array = this.bl_tree;
				if (1UL > (ulong)10L)
				{
				}
			}
			if (tree != num)
			{
				short[] array2 = this.bl_tree;
			}
			short[] array3 = this.bl_tree;
			short[] array4 = this.bl_tree;
			i++;
			num2 += 2;
			while (i <= max_code)
			{
			}
		}

		// Token: 0x06007CA8 RID: 31912 RVA: 0x0019F430 File Offset: 0x0019D630
		[Token(Token = "0x6007CA8")]
		[Address(RVA = "0x2026C60", Offset = "0x2025660", VA = "0x182026C60")]
		internal int build_bl_tree()
		{
			int max_code = this.l_desc.max_code;
			short[] array = this.dyn_ltree;
			this.scan_tree(array, max_code);
			int max_code2 = this.d_desc.max_code;
			short[] array2 = this.dyn_dtree;
			this.scan_tree(array2, max_code2);
			this.bl_desc.build_tree(this);
			short[] array3 = this.bl_tree;
			byte[] bl_order = ZTree.bl_order;
			uint num;
			if ("{il2cpp array field local12->}" == (ulong)0L)
			{
				while (num >= (uint)3)
				{
				}
			}
			byte b = (byte)((uint)b + num);
			throw new NullReferenceException();
		}

		// Token: 0x06007CA9 RID: 31913 RVA: 0x0019F4AC File Offset: 0x0019D6AC
		[Token(Token = "0x6007CA9")]
		[Address(RVA = "0x202A1F0", Offset = "0x2028BF0", VA = "0x18202A1F0")]
		internal void send_all_trees(int lcodes, int dcodes, int blcodes)
		{
			this.send_bits(lcodes, 5);
			this.send_bits(lcodes, 5);
			this.send_bits(lcodes, 4);
			int num = 0;
			if (blcodes > 0)
			{
				short[] array = this.bl_tree;
				byte[] bl_order = ZTree.bl_order;
				num++;
			}
			short[] array2 = this.dyn_ltree;
			int num2 = lcodes - 1;
			this.send_tree(array2, num2);
			short[] array3 = this.dyn_dtree;
			this.send_tree(array3, num2);
		}

		// Token: 0x06007CAA RID: 31914 RVA: 0x0019F518 File Offset: 0x0019D718
		[Token(Token = "0x6007CAA")]
		[Address(RVA = "0x202A4D0", Offset = "0x2028ED0", VA = "0x18202A4D0")]
		internal void send_tree(short[] tree, int max_code)
		{
			int num = 0;
			int num2 = 0;
			num2 += 3;
			uint num3;
			if (1U < num3)
			{
			}
			short[] array = this.bl_tree;
			if (1UL > (ulong)10L)
			{
				this.send_code((int)num3, array);
				uint num4;
				this.send_bits((int)num3, (int)num4);
			}
			uint num5;
			this.send_code((int)num5, array);
			this.send_bits((int)num5, 3);
			short[] array2 = this.bl_tree;
			this.send_code((int)num3, array2);
			short[] array3 = this.bl_tree;
			this.send_code(16, array3);
			this.send_bits(16, 2);
			short[] array4 = this.bl_tree;
			this.send_code(16, array4);
			while (num2 != 0)
			{
			}
			num++;
			num2 += 2;
		}

		// Token: 0x06007CAB RID: 31915 RVA: 0x0019F5BC File Offset: 0x0019D7BC
		[Token(Token = "0x6007CAB")]
		[Address(RVA = "0x2029E80", Offset = "0x2028880", VA = "0x182029E80")]
		internal void put_byte(byte[] p, int start, int len)
		{
			byte[] array = this.pending_buf;
			int num = this.pending;
			Array.Copy(p, start, array, num, len);
		}

		// Token: 0x06007CAC RID: 31916 RVA: 0x0019F5E4 File Offset: 0x0019D7E4
		[Token(Token = "0x6007CAC")]
		[Address(RVA = "0x2029ED0", Offset = "0x20288D0", VA = "0x182029ED0")]
		internal void put_byte(byte c)
		{
			int num = this.pending;
			byte[] array = this.pending_buf;
			int num2 = num + 1;
			this.pending = num2;
		}

		// Token: 0x06007CAD RID: 31917 RVA: 0x0019F610 File Offset: 0x0019D810
		[Token(Token = "0x6007CAD")]
		[Address(RVA = "0x2029F10", Offset = "0x2028910", VA = "0x182029F10")]
		internal void put_short(int w)
		{
			byte[] array = this.pending_buf;
			int num = this.pending + 1;
			this.pending = num;
			int num2 = this.pending;
			byte[] array2 = this.pending_buf;
			int num3 = num2 + 1;
			this.pending = num3;
		}

		// Token: 0x06007CAE RID: 31918 RVA: 0x0019F658 File Offset: 0x0019D858
		[Token(Token = "0x6007CAE")]
		[Address(RVA = "0x2029E00", Offset = "0x2028800", VA = "0x182029E00")]
		internal void putShortMSB(int b)
		{
			int num = this.pending;
			byte[] array = this.pending_buf;
			int num2 = num + 1;
			this.pending = num2;
			int num3 = this.pending;
			byte[] array2 = this.pending_buf;
			int num4 = num3 + 1;
			this.pending = num4;
		}

		// Token: 0x06007CAF RID: 31919 RVA: 0x0019F6A0 File Offset: 0x0019D8A0
		[Token(Token = "0x6007CAF")]
		[Address(RVA = "0x202A460", Offset = "0x2028E60", VA = "0x18202A460")]
		internal void send_code(int c, short[] tree)
		{
			int length = tree.Length;
			short num;
			short num2;
			this.send_bits((int)num, (int)num2);
		}

		// Token: 0x06007CB0 RID: 31920 RVA: 0x0019F6C4 File Offset: 0x0019D8C4
		[Token(Token = "0x6007CB0")]
		[Address(RVA = "0x202A370", Offset = "0x2028D70", VA = "0x18202A370")]
		internal void send_bits(int val, int length)
		{
			int num = this.bi_valid;
			uint num2;
			num2 -= (uint)length;
			this.bi_buf = (uint)val;
		}

		// Token: 0x06007CB1 RID: 31921 RVA: 0x0019F750 File Offset: 0x0019D950
		[Token(Token = "0x6007CB1")]
		[Address(RVA = "0x2025FF0", Offset = "0x20249F0", VA = "0x182025FF0")]
		internal void _tr_align()
		{
			this.send_bits(2, 3);
			short[] static_ltree = StaticTree.static_ltree;
			int length = static_ltree.Length;
			short num = static_ltree[128];
			short num2 = static_ltree[128];
			this.send_bits((int)num2, (int)num);
			this.bi_flush();
			int num3 = this.last_eob_len;
			num3 += 11;
			if (num3 < 9)
			{
				this.send_bits(2, 3);
				short[] static_ltree2 = StaticTree.static_ltree;
				int length2 = static_ltree2.Length;
				short num4 = static_ltree2[128];
				short num5 = static_ltree2[128];
				this.send_bits((int)num5, (int)num4);
				this.bi_flush();
			}
			this.last_eob_len = (int)((ulong)7L);
		}

		// Token: 0x06007CB2 RID: 31922 RVA: 0x0019F800 File Offset: 0x0019DA00
		[Token(Token = "0x6007CB2")]
		[Address(RVA = "0x2026750", Offset = "0x2025150", VA = "0x182026750")]
		internal bool _tr_tally(int dist, int lc)
		{
			byte[] array = this.pending_buf;
			int num = this.last_lit;
			int num2 = this.d_buf;
			byte[] array2 = this.pending_buf;
			int num3 = this.d_buf;
			num3++;
			byte[] array3 = this.pending_buf;
			num3 = this.l_buf;
			short[] array4 = this.dyn_ltree;
			if (dist != 0)
			{
				byte[] length_code = ZTree._length_code;
				short[] array5 = this.dyn_dtree;
				int num4 = ZTree.d_code(dist - 1);
				num4 += num4;
			}
			if (this.last_lit == 8191 && this.level > 2)
			{
				int num5 = 0;
				short[] array6 = this.dyn_dtree;
				int[] extra_dbits = ZTree.extra_dbits;
				num5 += 2;
				num5++;
				int num6 = extra_dbits[num5];
				num6 += 5;
				int num7 = num6 * num5;
				int num8 = this.last_lit;
				num8 -= array6;
				if (this.matches < num8)
				{
					num8 -= array6;
				}
			}
			int num9 = this.lit_bufsize;
			throw new NullReferenceException();
		}

		// Token: 0x06007CB3 RID: 31923 RVA: 0x0019F8F4 File Offset: 0x0019DAF4
		[Token(Token = "0x6007CB3")]
		[Address(RVA = "0x2026DC0", Offset = "0x20257C0", VA = "0x182026DC0")]
		internal void compress_block(short[] ltree, short[] dtree)
		{
			int num = 0;
			if (this.last_lit != num)
			{
				byte[] array = this.pending_buf;
				int num2 = this.d_buf;
				int length = array.Length;
				num2 += num;
				int num3 = num2 + 1;
				int num4 = this.l_buf;
				num4 += num;
				num += 2;
				num++;
				byte[] length_code = ZTree._length_code;
				int length2 = ltree.Length;
				short num5 = ltree[length_code];
				short num6 = ltree[length_code];
				this.send_bits((int)num6, (int)num5);
				int[] extra_lbits = ZTree.extra_lbits;
				int num7;
				if (num7 != 0)
				{
					int[] base_length = ZTree.base_length;
					byte b;
					this.send_bits((int)b, num7);
				}
				byte b2;
				int num8 = ZTree.d_code((int)b2);
				this.send_bits(1, (int)num5);
				if (ZTree.extra_dbits[num8] != 0)
				{
					int[] base_dist = ZTree.base_dist;
					int length3 = ltree.Length;
					num4++;
					short num9 = ltree[num4];
					short num10 = ltree[num4];
					this.send_bits((int)num10, (int)num9);
				}
				if (num < this.last_lit)
				{
				}
			}
			int length4 = ltree.Length;
			short num11 = ltree[128];
			short num12 = ltree[128];
			this.send_bits((int)num12, (int)num11);
			this.last_eob_len = length4;
		}

		// Token: 0x06007CB4 RID: 31924 RVA: 0x0019FA28 File Offset: 0x0019DC28
		[Token(Token = "0x6007CB4")]
		[Address(RVA = "0x202A6D0", Offset = "0x20290D0", VA = "0x18202A6D0")]
		internal void set_data_type()
		{
			short[] array = this.dyn_ltree;
			int num = 0;
			int length = array.Length;
			num++;
			num += 2;
			num += this;
			if (num < 128)
			{
				num++;
				num += this;
			}
			if (num < 256)
			{
				num += this;
			}
			bool flag = num <= num;
			this.data_type = (flag ? 1 : 0);
		}

		// Token: 0x06007CB5 RID: 31925 RVA: 0x0019FA84 File Offset: 0x0019DC84
		[Token(Token = "0x6007CB5")]
		[Address(RVA = "0x2026A90", Offset = "0x2025490", VA = "0x182026A90")]
		internal void bi_flush()
		{
			if (this.bi_valid != 16)
			{
				int num = this.pending;
				byte[] array = this.pending_buf;
				uint num2 = this.bi_buf;
				int num3 = num + 1;
				this.pending = num3;
				this.bi_buf = (uint)num3;
				return;
			}
			int num4 = this.pending;
			byte[] array2 = this.pending_buf;
			uint num5 = this.bi_buf;
			int num6 = num4 + 1;
			this.pending = num6;
			int num7 = this.pending;
			byte[] array3 = this.pending_buf;
			uint num8 = this.bi_buf;
			int num9 = num7 + 1;
			this.pending = num9;
			int num10 = 0;
			this.bi_buf = (uint)num10;
		}

		// Token: 0x06007CB6 RID: 31926 RVA: 0x0019FB20 File Offset: 0x0019DD20
		[Token(Token = "0x6007CB6")]
		[Address(RVA = "0x2026B80", Offset = "0x2025580", VA = "0x182026B80")]
		internal void bi_windup()
		{
			if (this.bi_valid > 0)
			{
				int num = this.pending;
				byte[] array = this.pending_buf;
				uint num2 = this.bi_buf;
				int num3 = num + 1;
				this.pending = num3;
				int num4 = 0;
				this.bi_buf = (uint)num4;
				return;
			}
			int num5 = 0;
			this.bi_buf = (uint)num5;
		}

		// Token: 0x06007CB7 RID: 31927 RVA: 0x0019FBC0 File Offset: 0x0019DDC0
		[Token(Token = "0x6007CB7")]
		[Address(RVA = "0x2027270", Offset = "0x2025C70", VA = "0x182027270")]
		internal void copy_block(int buf, int len, bool header)
		{
			int num = 0;
			this.bi_windup();
			this.last_eob_len = (int)((ulong)8L);
			if (header)
			{
				this.put_short(num);
				this.put_short(num);
			}
			int num2 = this.pending;
			byte[] array = this.pending_buf;
			Array.Copy(this.window, buf, array, num2, len);
		}

		// Token: 0x06007CB8 RID: 31928 RVA: 0x0019FC10 File Offset: 0x0019DE10
		[Token(Token = "0x6007CB8")]
		[Address(RVA = "0x20291C0", Offset = "0x2027BC0", VA = "0x1820291C0")]
		internal void flush_block_only(bool eof)
		{
			int num = this.block_start;
			int num2 = this.strstart;
			num2 -= num;
			this._tr_flush_block(num, num2, eof);
			ZStream zstream = this.strm;
			int num3 = this.strstart;
			this.block_start = num3;
			zstream.flush_pending();
		}

		// Token: 0x06007CB9 RID: 31929 RVA: 0x0019FC5C File Offset: 0x0019DE5C
		[Token(Token = "0x6007CB9")]
		[Address(RVA = "0x2028D20", Offset = "0x2027720", VA = "0x182028D20")]
		internal int deflate_stored(int flush)
		{
			int num2;
			do
			{
				int num = this.pending_buf_size;
				num += -5;
				num2 = 0;
				int num3 = this.lookahead;
				this.fill_window();
				int num4 = this.lookahead;
				if (num4 == 0)
				{
					if (flush == 0)
					{
						break;
					}
					if (num4 == 0)
					{
						goto IL_107;
					}
				}
				int num5 = this.block_start;
				int num6 = this.strstart;
				this.lookahead = num2;
				if (num4 != 0)
				{
				}
				num6 -= this;
				this.strstart = this;
				this.lookahead = num6;
				int num7 = 0;
				num5 = num;
				this._tr_flush_block(num5, num5, num7 != 0);
				ZStream zstream = this.strm;
				int num8 = this.strstart;
				this.block_start = num8;
				zstream.flush_pending();
				if (this.strm.avail_out == num2)
				{
					break;
				}
				int num9 = this.strstart;
				int num10 = this.w_size;
				int num11 = this.block_start;
				num9 -= num11;
				int num12 = 0;
				this._tr_flush_block(num11, num9, num12 != 0);
				ZStream zstream2 = this.strm;
				int num13 = this.strstart;
				this.block_start = num13;
				zstream2.flush_pending();
			}
			while (this.strm.avail_out != num2);
			return 0;
			IL_107:
			bool flag = flush == 4;
			this.flush_block_only(flag);
			if (this.strm.avail_out != num2)
			{
			}
			while (flush != 4)
			{
			}
			throw new NullReferenceException();
		}

		// Token: 0x06007CBA RID: 31930 RVA: 0x0019FD98 File Offset: 0x0019DF98
		[Token(Token = "0x6007CBA")]
		[Address(RVA = "0x20266B0", Offset = "0x20250B0", VA = "0x1820266B0")]
		internal void _tr_stored_block(int buf, int stored_len, bool eof)
		{
			this.send_bits(eof ? 1 : 0, 3);
			int num = 0;
			this.bi_windup();
			this.last_eob_len = (int)((ulong)8L);
			this.put_short(num);
			this.put_short(num);
			int num2 = this.pending;
			byte[] array = this.pending_buf;
			Array.Copy(this.window, buf, array, num2, stored_len);
		}

		// Token: 0x06007CBB RID: 31931 RVA: 0x0019FDF0 File Offset: 0x0019DFF0
		[Token(Token = "0x6007CBB")]
		[Address(RVA = "0x2026190", Offset = "0x2024B90", VA = "0x182026190")]
		internal void _tr_flush_block(int buf, int stored_len, bool eof)
		{
			int num = 0;
			int length = this.dyn_ltree.Length;
			num++;
			num += 2;
			if (num < 128)
			{
				num++;
			}
			if (num < 256)
			{
			}
			bool flag = num <= num;
			this.data_type = (flag ? 1 : 0);
			this.l_desc.build_tree(this);
			this.d_desc.build_tree(this);
			int max_code = this.l_desc.max_code;
			short[] array = this.dyn_ltree;
			this.scan_tree(array, max_code);
			int max_code2 = this.d_desc.max_code;
			short[] array2 = this.dyn_dtree;
			this.scan_tree(array2, max_code2);
			this.bl_desc.build_tree(this);
			short[] array3 = this.bl_tree;
			byte[] bl_order = ZTree.bl_order;
			uint num2;
			if ("{il2cpp array field local23->}" == num)
			{
				while (num2 >= (uint)3)
				{
				}
			}
			int num3 = this.static_len;
			num2 += num2;
			num3 += 10;
			int num4 = this.opt_len;
			num4 += 10;
			if (num3 <= num4)
			{
				num4 = num3;
			}
			if (buf != -1)
			{
				num4 = buf;
				this._tr_stored_block(num4, stored_len, eof);
			}
			if (this != num4)
			{
				this.send_bits(num4, 3);
				ZTree ztree = this.l_desc;
				ZTree ztree2 = this.d_desc;
				uint num5 = num2 + 1U;
				int max_code3 = ztree.max_code;
				this.send_bits(num4, 5);
				this.send_bits(num4, 5);
				this.send_bits(num4, 4);
				if (num5 > (uint)0)
				{
					short[] array4 = this.bl_tree;
					byte[] bl_order2 = ZTree.bl_order;
					this.send_bits(num4, 3);
					num++;
				}
				short[] array5 = this.dyn_ltree;
				this.send_tree(array5, max_code3);
				short[] array6 = this.dyn_dtree;
				this.send_tree(array6, max_code3);
			}
			short[] static_dtree = StaticTree.static_dtree;
			short[] static_ltree = StaticTree.static_ltree;
			this.compress_block(static_ltree, static_dtree);
			this.init_block();
			if (eof)
			{
				this.bi_windup();
			}
		}

		// Token: 0x06007CBC RID: 31932 RVA: 0x0019FFB4 File Offset: 0x0019E1B4
		[Token(Token = "0x6007CBC")]
		[Address(RVA = "0x2028ED0", Offset = "0x20278D0", VA = "0x182028ED0")]
		internal void fill_window()
		{
			int num2;
			byte[] array4;
			do
			{
				int num = this.lookahead;
				num2 = 0;
				int num3 = this.window_size;
				int num4 = this.strstart;
				num3 -= num4;
				num3 -= num;
				int num13;
				if (num4 != 0 || num != 0 || this.w_size != -1)
				{
					int num5 = this.w_size;
					byte[] array = this.window;
					int num6 = 0;
					Array.Copy(array, num5, array, num6, num5);
					int num7 = this.hash_size;
					num5 = num7;
					short[] array2 = this.head;
					short num8 = array2[num5];
					int num9 = this.w_size;
					num8 = (short)((int)num8 - num9);
					array2[0] = (short)num2;
					int num10 = num7 - 1;
					while (num10 != 0)
					{
					}
					int num11 = this.w_size;
					num5 = num11;
					short[] array3 = this.prev;
					short num12 = array3[num5];
					num13 = this.w_size;
					num12 = (short)((int)num12 - num13);
					array3[0] = (short)num2;
					int num14 = num11 - 1;
					while (num14 != 0)
					{
					}
				}
				ZStream zstream = this.strm;
				int num15 = zstream.avail_in;
				if (num15 == 0)
				{
					break;
				}
				array4 = this.window;
				if (num15 != 0)
				{
					num15 -= num15;
					zstream.avail_in = num15;
					int next_in_index;
					if (zstream.dstate.noheader == num2)
					{
						Adler32 adler = zstream._adler;
						next_in_index = zstream.next_in_index;
						byte[] next_in = zstream.next_in;
						long adler2 = zstream.adler;
						long num16 = adler.adler32(adler2, next_in, next_in_index, num15);
						zstream.adler = num16;
					}
					int next_in_index2 = zstream.next_in_index;
					Array.Copy(zstream.next_in, next_in_index2, array4, next_in_index, num15);
				}
				this.lookahead = array4;
				byte[] array5 = this.window;
				num13 = this.strstart;
				byte b;
				this.ins_h = (int)b;
				num13++;
				this.ins_h = (int)b;
			}
			while (array4 < (ulong)262L && this.strm.avail_in != num2);
		}

		// Token: 0x06007CBD RID: 31933 RVA: 0x001A0194 File Offset: 0x0019E394
		[Token(Token = "0x6007CBD")]
		[Address(RVA = "0x2027DB0", Offset = "0x20267B0", VA = "0x182027DB0")]
		internal int deflate_fast(int flush)
		{
			int num;
			do
			{
				num = 0;
				if (this.lookahead < 262)
				{
					this.fill_window();
					int num2 = this.lookahead;
					if (num2 < 262 && flush == 0)
					{
						break;
					}
					if (num2 == 0)
					{
						goto IL_27F;
					}
				}
				byte[] array = this.window;
				int num3 = this.strstart;
				int num4 = this.ins_h;
				short[] array2 = this.head;
				this.ins_h = num4;
				short num5 = array2[num4];
				short[] array3 = this.prev;
				int num6 = this.w_mask;
				array3[0] = num5;
				short[] array4 = this.head;
				int num7 = this.ins_h;
				int num8 = this.strstart;
				array4[0] = (short)num8;
				int num9 = this.strstart;
				num9 -= (int)num5;
				int num10 = this.w_size;
				if (this.strategy != 2)
				{
					int num11 = this.longest_match((int)num5);
					this.match_length = num11;
				}
				bool flag;
				int num14;
				if (this.match_length < 3)
				{
					byte[] array5 = this.window;
					int num12 = this.strstart;
					int num13 = 0;
					byte b;
					flag = this._tr_tally(num13, (int)b);
					num14 = this.strstart;
				}
				int num15 = this.strstart;
				num14 += -3;
				bool flag2 = this._tr_tally(num15, num14);
				int num16 = this.match_length;
				flag = flag2;
				int num17 = this.lookahead;
				num17 -= num16;
				this.lookahead = num17;
				int num18 = num16 - 1;
				this.match_length = num18;
				int num19 = this.strstart;
				byte[] array6 = this.window;
				int num20 = num19 + 1;
				this.strstart = num20;
				int num21 = this.ins_h;
				short[] array7 = this.head;
				this.ins_h = num21;
				short num22 = array7[num21];
				short[] array8 = this.prev;
				int num23 = this.w_mask;
				array8[0] = num22;
				short[] array9 = this.head;
				int num24 = this.ins_h;
				num23 = num24;
				int num25 = this.strstart;
				array9[0] = (short)num25;
				while (num24 != array9.Length)
				{
				}
				int num26 = this.strstart;
				byte[] array10 = this.window;
				num26 += num23;
				this.strstart = num26;
				this.match_length = num;
				num3 = num26;
				byte b2 = array10[num3];
				this.ins_h = (int)b2;
				num3++;
				this.ins_h = (int)b2;
				while (!flag)
				{
				}
				int num27 = this.block_start;
				num26 -= num27;
				int num28 = 0;
				this._tr_flush_block(num27, num26, num28 != 0);
				ZStream zstream = this.strm;
				int num29 = this.strstart;
				this.block_start = num29;
				zstream.flush_pending();
			}
			while (this.strm.avail_out != num);
			return 0;
			IL_27F:
			int num30 = this.block_start;
			int num31 = this.strstart;
			bool flag3 = flush == 4;
			num31 -= num30;
			this._tr_flush_block(num30, num31, flag3);
			ZStream zstream2 = this.strm;
			int num32 = this.strstart;
			this.block_start = num32;
			zstream2.flush_pending();
			if (this.strm.avail_out != num)
			{
			}
			throw new NullReferenceException();
		}

		// Token: 0x06007CBE RID: 31934 RVA: 0x001A047C File Offset: 0x0019E67C
		[Token(Token = "0x6007CBE")]
		[Address(RVA = "0x20287A0", Offset = "0x20271A0", VA = "0x1820287A0")]
		internal int deflate_slow(int flush)
		{
			int num;
			do
			{
				num = 0;
				if (this.lookahead < 262)
				{
					this.fill_window();
					int num2 = this.lookahead;
					if (num2 < 262 && flush == 0)
					{
						break;
					}
					if (num2 == 0)
					{
						goto IL_277;
					}
				}
				byte[] array = this.window;
				int num3 = this.strstart;
				int num4 = this.ins_h;
				short[] array2 = this.head;
				this.ins_h = num4;
				short num5 = array2[num4];
				short[] array3 = this.prev;
				int num6 = this.w_mask;
				array3[0] = num5;
				short[] array4 = this.head;
				int num7 = this.ins_h;
				int num8 = this.strstart;
				array4[0] = (short)num8;
				int num9 = this.match_length;
				int num10 = this.match_start;
				this.prev_length = num9;
				this.prev_match = num10;
				this.match_length = 2;
				if (num9 < this.max_lazy_match)
				{
					int num11 = this.strstart;
					num11 -= (int)num5;
					int num12 = this.w_size;
					if (this.strategy != 2)
					{
						int num13 = this.longest_match((int)num5);
						this.match_length = num13;
					}
					if (this.strategy == 1 || (2 == 3 && this.strstart > 4096))
					{
						this.match_length = 2;
					}
				}
				int num14 = this.strstart;
				num9 += -3;
				int num15 = this.lookahead;
				num15 += -3;
				num15 += num14;
				bool flag = this._tr_tally(num14, num9);
				int num16 = this.prev_length;
				this.prev_length = 1;
				int num17 = this.strstart;
				int num18 = num17 + 1;
				this.strstart = num18;
				byte[] array5 = this.window;
				int num19 = this.ins_h;
				short[] array6 = this.head;
				this.ins_h = num19;
				short num20 = array6[num19];
				short[] array7 = this.prev;
				int num21 = this.w_mask;
				array7[0] = num20;
				short[] array8 = this.head;
				int num22 = this.ins_h;
				int num23 = this.strstart;
				array8[0] = (short)num23;
				while (num22 != array8.Length)
				{
				}
				int num24 = this.strstart;
				num24++;
				this.match_available = num;
				this.match_length = 2;
				this.strstart = num24;
				while (!flag)
				{
				}
				int num25 = this.block_start;
				num24 -= num25;
				int num26 = 0;
				this._tr_flush_block(num25, num24, num26 != 0);
				ZStream zstream = this.strm;
				int num27 = this.strstart;
				this.block_start = num27;
				zstream.flush_pending();
			}
			while (this.strm.avail_out != num);
			return 0;
			IL_277:
			if (this.match_available != num)
			{
				byte[] array9 = this.window;
				int num28 = this.strstart;
				int num29 = 0;
				byte b;
				bool flag2 = this._tr_tally(num29, (int)b);
				this.match_available = num;
			}
			bool flag3 = flush == 4;
			this.flush_block_only(flag3);
			if (this.strm.avail_out != num)
			{
			}
			throw new NullReferenceException();
		}

		// Token: 0x06007CBF RID: 31935 RVA: 0x001A0750 File Offset: 0x0019E950
		[Token(Token = "0x6007CBF")]
		[Address(RVA = "0x2029580", Offset = "0x2027F80", VA = "0x182029580")]
		internal int longest_match(int cur_match)
		{
			int num = this.w_size;
			int num2 = this.strstart;
			int num3 = this.max_chain_length;
			int num4 = this.prev_length;
			num2 -= num;
			num2 += 262;
			int num5 = 0;
			byte[] array = this.window;
			int num6 = this.nice_match;
			int length = array.Length;
			int num7 = cur_match - 1;
			int num8 = this.lookahead;
			if (num6 <= num8)
			{
			}
			int length2 = array.Length;
			num8 = cur_match + 1;
			int num9 = num2 + 1;
			int length3 = array.Length;
			num6 = num3;
			int num10 = num6 + 1;
			int num11 = cur_match + 1;
			int num12 = cur_match + 1;
			num12 = num3;
			num12 += 3;
			int num13 = cur_match + 1;
			int num14 = cur_match + 1;
			num14 = num3;
			num14 += 5;
			int num15 = cur_match + 1;
			int num16 = cur_match + 1;
			num16 = num3;
			num16 += 7;
			int num17 = cur_match + 1;
			num3 += 8;
			if (cur_match > num4)
			{
				this.match_start = cur_match;
				int length4 = array.Length;
				byte b2;
				byte b = b2 - 1;
			}
			short[] array2 = this.prev;
			int num18 = this.w_mask;
			if ((int)array2[num18] > num5)
			{
				int num19 = num3 - 1;
				if (num19 != 0)
				{
				}
			}
			return cur_match;
		}

		// Token: 0x06007CC0 RID: 31936 RVA: 0x001A087C File Offset: 0x0019EA7C
		[Token(Token = "0x6007CC0")]
		[Address(RVA = "0x20276C0", Offset = "0x20260C0", VA = "0x1820276C0")]
		internal int deflateInit(ZStream strm, int level, int bits)
		{
			int num = 0;
			ulong num2;
			return this.deflateInit2(strm, level, 8, bits, (int)num2, num);
		}

		// Token: 0x06007CC1 RID: 31937 RVA: 0x001A0898 File Offset: 0x0019EA98
		[Token(Token = "0x6007CC1")]
		[Address(RVA = "0x2027690", Offset = "0x2026090", VA = "0x182027690")]
		internal int deflateInit(ZStream strm, int level)
		{
			int num = 0;
			ulong num2;
			ulong num3;
			return this.deflateInit2(strm, level, 8, (int)num2, (int)num3, num);
		}

		// Token: 0x06007CC2 RID: 31938 RVA: 0x001A08B4 File Offset: 0x0019EAB4
		[Token(Token = "0x6007CC2")]
		[Address(RVA = "0x2027340", Offset = "0x2025D40", VA = "0x182027340")]
		internal int deflateInit2(ZStream strm, int level, int method, int windowBits, int memLevel, int strategy)
		{
			int num = 0;
			strm.msg = num;
			if (method == 8 && level <= 9)
			{
				strm.dstate = this;
				this.w_bits = 0;
				this.noheader = 0;
				uint num2;
				this.w_size = (int)num2;
				this.hash_bits = 0;
				uint num3 = num2 - 1U;
				this.w_mask = (int)num3;
				uint num4;
				this.hash_size = (int)num4;
				uint num5 = num4 - 1U;
				this.hash_mask = (int)num5;
				byte[] array = new byte[0];
				int num6 = this.w_size;
				this.window = array;
				short[] array2 = new short[num6];
				int num7 = this.hash_size;
				this.prev = array2;
				short[] array3 = new short[num7];
				this.head = array3;
				uint num8;
				this.lit_bufsize = (int)num8;
				byte[] array4 = new byte[1];
				int num9 = this.lit_bufsize;
				this.pending_buf = array4;
				this.level = level;
				this.strategy = 0;
				this.method = (byte)method;
				this.pending_buf_size = array4;
				num9 -= (int)num8;
				this.d_buf = num9;
				this.l_buf = num9;
				strm.total_out = (long)num;
				strm.total_in = (long)num;
				strm.msg = num;
				strm.data_type = (int)((ulong)2L);
				int num10 = this.noheader;
				this.pending_out = num;
				this.noheader = num;
				uint num11;
				this.status = (int)num11;
				strm.adler = (long)((ulong)1L);
				this.last_flush = num;
				ZTree ztree = this.l_desc;
				short[] array5 = this.dyn_ltree;
				ztree.dyn_tree = array5;
				ZTree ztree2 = this.l_desc;
				StaticTree static_l_desc = StaticTree.static_l_desc;
				ztree2.stat_desc = static_l_desc;
				ZTree ztree3 = this.d_desc;
				short[] array6 = this.dyn_dtree;
				ztree3.dyn_tree = array6;
				ZTree ztree4 = this.d_desc;
				StaticTree static_d_desc = StaticTree.static_d_desc;
				ztree4.stat_desc = static_d_desc;
				ZTree ztree5 = this.bl_desc;
				short[] array7 = this.bl_tree;
				ztree5.dyn_tree = array7;
				ZTree ztree6 = this.bl_desc;
				StaticTree static_bl_desc = StaticTree.static_bl_desc;
				ztree6.stat_desc = static_bl_desc;
				this.bi_buf = (uint)num;
				this.last_eob_len = (int)((ulong)8L);
				this.init_block();
				this.lm_init();
				return 0;
			}
			throw new NullReferenceException();
		}

		// Token: 0x06007CC3 RID: 31939 RVA: 0x001A0AB4 File Offset: 0x0019ECB4
		[Token(Token = "0x6007CC3")]
		[Address(RVA = "0x20279D0", Offset = "0x20263D0", VA = "0x1820279D0")]
		internal int deflateReset(ZStream strm)
		{
			int num = 0;
			strm.data_type = (int)((ulong)2L);
			strm.total_out = (long)num;
			strm.total_in = (long)num;
			strm.msg = num;
			this.pending_out = num;
			int num2 = this.noheader;
			this.noheader = num;
			this.status = (int)((uint)42);
			strm.adler = (long)((ulong)1L);
			this.last_flush = num;
			ZTree ztree = this.l_desc;
			short[] array = this.dyn_ltree;
			ztree.dyn_tree = array;
			ZTree ztree2 = this.l_desc;
			StaticTree static_l_desc = StaticTree.static_l_desc;
			ztree2.stat_desc = static_l_desc;
			ZTree ztree3 = this.d_desc;
			short[] array2 = this.dyn_dtree;
			ztree3.dyn_tree = array2;
			ZTree ztree4 = this.d_desc;
			StaticTree static_d_desc = StaticTree.static_d_desc;
			ztree4.stat_desc = static_d_desc;
			ZTree ztree5 = this.bl_desc;
			short[] array3 = this.bl_tree;
			ztree5.dyn_tree = array3;
			ZTree ztree6 = this.bl_desc;
			StaticTree static_bl_desc = StaticTree.static_bl_desc;
			ztree6.stat_desc = static_bl_desc;
			this.bi_buf = (uint)num;
			this.last_eob_len = (int)((ulong)8L);
			this.init_block();
			this.lm_init();
			return 0;
		}

		// Token: 0x06007CC4 RID: 31940 RVA: 0x001A0BC4 File Offset: 0x0019EDC4
		[Token(Token = "0x6007CC4")]
		[Address(RVA = "0x2027300", Offset = "0x2025D00", VA = "0x182027300")]
		internal int deflateEnd()
		{
			int num = this.status;
			if (num != 42 && num != 113 && num != 666)
			{
				return -2;
			}
			int num2 = 0;
			this.pending_buf = num2;
			this.head = num2;
			this.prev = num2;
			this.window = num2;
			return -3;
		}

		// Token: 0x06007CC5 RID: 31941 RVA: 0x001A0C10 File Offset: 0x0019EE10
		[Token(Token = "0x6007CC5")]
		[Address(RVA = "0x20276F0", Offset = "0x20260F0", VA = "0x1820276F0")]
		internal int deflateParams(ZStream strm, int _level, int _strategy)
		{
			int num = 0;
			if (_level <= 9 && _strategy <= 2)
			{
				Deflate.Config[] array = Deflate.config_table;
				int num2 = this.level;
				int length = array.Length;
				int func = array[num2].func;
				Deflate.Config config = array[_level];
				if (func != config.func && strm.total_in != (long)num)
				{
					Deflate dstate = strm.dstate;
					if (dstate != 0)
					{
						int num3 = dstate.deflate(strm, 1);
					}
				}
				if (num2 != _level)
				{
					this.level = _level;
					Deflate.Config[] array2 = Deflate.config_table;
					int num4 = this.level;
					int max_lazy = array2[num4].max_lazy;
					this.max_lazy_match = max_lazy;
					int good_length = Deflate.config_table[num4].good_length;
					this.good_match = good_length;
					int nice_length = Deflate.config_table[num4].nice_length;
					this.nice_match = nice_length;
					int max_chain = Deflate.config_table[num4].max_chain;
					this.max_chain_length = max_chain;
				}
				this.strategy = _strategy;
			}
			return -2;
		}

		// Token: 0x06007CC6 RID: 31942 RVA: 0x001A0D18 File Offset: 0x0019EF18
		[Token(Token = "0x6007CC6")]
		[Address(RVA = "0x2027B70", Offset = "0x2026570", VA = "0x182027B70")]
		internal int deflateSetDictionary(ZStream strm, byte[] dictionary, int dictLength)
		{
			int i = 0;
			if (dictionary != 0 && this.status == 42)
			{
				Adler32 adler = strm._adler;
				long adler2 = strm.adler;
				int num = 0;
				long num2 = adler.adler32(adler2, dictionary, num, dictLength);
				strm.adler = num2;
				int num3 = this.w_size;
				num3 += -262;
				if (dictLength > num3)
				{
				}
				byte[] array = this.window;
				int num4 = 0;
				Array.Copy(dictionary, i, array, num4, dictLength);
				byte[] array2 = this.window;
				this.strstart = dictLength;
				this.block_start = dictLength;
				byte b = array2[0];
				this.ins_h = (int)b;
				this.ins_h = (int)b;
				byte[] array3 = this.window;
				int num5 = this.ins_h;
				short[] array4 = this.head;
				this.ins_h = num5;
				short[] array5 = this.prev;
				int num6 = this.w_mask;
				short num7 = array4[num5];
				array5[0] = num7;
				short[] array6 = this.head;
				int num8 = this.ins_h;
				array6[0] = (short)i;
				i++;
				while (i <= dictLength)
				{
				}
			}
			throw new IndexOutOfRangeException();
		}

		// Token: 0x06007CC7 RID: 31943 RVA: 0x001A0E28 File Offset: 0x0019F028
		[Token(Token = "0x6007CC7")]
		[Address(RVA = "0x20282B0", Offset = "0x2026CB0", VA = "0x1820282B0")]
		internal int deflate(ZStream strm, int flush)
		{
			if (flush <= 4)
			{
				if (strm.next_out != (ulong)0L && (strm.next_in != (ulong)0L || strm.avail_in == 0))
				{
					int num = this.status;
					if (num != 666 || flush == 4)
					{
						if (strm.avail_out != 0)
						{
							int num2 = this.last_flush;
							this.last_flush = flush;
							this.strm = strm;
							if (num == 42)
							{
								int num3 = this.level;
								this.status = (int)((ulong)113L);
								ulong num4;
								num4 += (ulong)1L;
								num4 += num4;
								long num5 = (long)(num4 * (ulong)((uint)31));
								this.putShortMSB((int)num5);
								if (this.strstart != 0)
								{
									long adler = strm.adler;
									this.putShortMSB((int)adler);
									long adler2 = strm.adler;
									this.putShortMSB((int)adler2);
								}
								strm.adler = (long)((ulong)1L);
							}
							if (this.pending == 0)
							{
								if (strm.avail_in != 0 || flush == 4)
								{
									goto IL_F9;
								}
								string[] array = Deflate.z_errmsg;
							}
							strm.flush_pending();
							if (strm.avail_out == 0)
							{
								goto IL_259;
							}
							IL_F9:
							string[] array2;
							if (this.status == 666)
							{
								if (strm.avail_in == 0)
								{
									goto IL_11F;
								}
								array2 = Deflate.z_errmsg;
							}
							if (strm.avail_in != 0)
							{
								goto IL_13D;
							}
							IL_11F:
							if (this.lookahead == 0 && (flush == 0 || array2 == (ulong)666L))
							{
								goto IL_204;
							}
							IL_13D:
							Deflate.Config[] array3 = Deflate.config_table;
							int num6 = this.level;
							int func = array3[num6].func;
							if (func != 0)
							{
								if (func != 0)
								{
									if (func != 1)
									{
										goto IL_19D;
									}
									int num7 = this.deflate_slow(flush);
								}
								int num8 = this.deflate_fast(flush);
							}
							int num9 = this.deflate_stored(flush);
							if (num9 == 2 || num9 == 3)
							{
								this.status = (int)((ulong)666L);
							}
							IL_19D:
							if (num9 == 0 || num9 == 2)
							{
								goto IL_250;
							}
							if (num9 == 1)
							{
								if (flush != num9)
								{
									int num10 = 0;
									int num11 = 0;
									int num12 = 0;
									int num13 = 0;
									this._tr_stored_block(num13, num12, num11 != 0);
									if (flush == 3 && this.hash_size > num10)
									{
										short[] array4 = this.head;
										num10++;
										array4[0] = (short)num10;
									}
								}
								strm.flush_pending();
								if (strm.avail_out == 0)
								{
									goto IL_259;
								}
							}
							IL_204:
							if (flush != 4)
							{
								goto IL_259;
							}
							if (this.noheader == 0)
							{
								long adler3 = strm.adler;
								this.putShortMSB((int)adler3);
								long adler4 = strm.adler;
								this.putShortMSB((int)adler4);
								strm.flush_pending();
								this.noheader = (int)((ulong)4294967295L);
								if (this.pending != 0)
								{
									goto IL_259;
								}
							}
							IL_250:
							if (strm.avail_out == 0)
							{
							}
						}
						IL_259:
						string text = Deflate.z_errmsg[7];
						strm.msg = text;
					}
				}
				string text2 = Deflate.z_errmsg[4];
				strm.msg = text2;
			}
			throw new IndexOutOfRangeException();
		}

		// Token: 0x040058A9 RID: 22697
		[Token(Token = "0x40058A9")]
		private const int MAX_MEM_LEVEL = 9;

		// Token: 0x040058AA RID: 22698
		[Token(Token = "0x40058AA")]
		private const int Z_DEFAULT_COMPRESSION = -1;

		// Token: 0x040058AB RID: 22699
		[Token(Token = "0x40058AB")]
		private const int MAX_WBITS = 15;

		// Token: 0x040058AC RID: 22700
		[Token(Token = "0x40058AC")]
		private const int DEF_MEM_LEVEL = 8;

		// Token: 0x040058AD RID: 22701
		[Token(Token = "0x40058AD")]
		private const int STORED = 0;

		// Token: 0x040058AE RID: 22702
		[Token(Token = "0x40058AE")]
		private const int FAST = 1;

		// Token: 0x040058AF RID: 22703
		[Token(Token = "0x40058AF")]
		private const int SLOW = 2;

		// Token: 0x040058B0 RID: 22704
		[Token(Token = "0x40058B0")]
		private static readonly Deflate.Config[] config_table;

		// Token: 0x040058B1 RID: 22705
		[Token(Token = "0x40058B1")]
		private static readonly string[] z_errmsg;

		// Token: 0x040058B2 RID: 22706
		[Token(Token = "0x40058B2")]
		private const int NeedMore = 0;

		// Token: 0x040058B3 RID: 22707
		[Token(Token = "0x40058B3")]
		private const int BlockDone = 1;

		// Token: 0x040058B4 RID: 22708
		[Token(Token = "0x40058B4")]
		private const int FinishStarted = 2;

		// Token: 0x040058B5 RID: 22709
		[Token(Token = "0x40058B5")]
		private const int FinishDone = 3;

		// Token: 0x040058B6 RID: 22710
		[Token(Token = "0x40058B6")]
		private const int PRESET_DICT = 32;

		// Token: 0x040058B7 RID: 22711
		[Token(Token = "0x40058B7")]
		private const int Z_FILTERED = 1;

		// Token: 0x040058B8 RID: 22712
		[Token(Token = "0x40058B8")]
		private const int Z_HUFFMAN_ONLY = 2;

		// Token: 0x040058B9 RID: 22713
		[Token(Token = "0x40058B9")]
		private const int Z_DEFAULT_STRATEGY = 0;

		// Token: 0x040058BA RID: 22714
		[Token(Token = "0x40058BA")]
		private const int Z_NO_FLUSH = 0;

		// Token: 0x040058BB RID: 22715
		[Token(Token = "0x40058BB")]
		private const int Z_PARTIAL_FLUSH = 1;

		// Token: 0x040058BC RID: 22716
		[Token(Token = "0x40058BC")]
		private const int Z_SYNC_FLUSH = 2;

		// Token: 0x040058BD RID: 22717
		[Token(Token = "0x40058BD")]
		private const int Z_FULL_FLUSH = 3;

		// Token: 0x040058BE RID: 22718
		[Token(Token = "0x40058BE")]
		private const int Z_FINISH = 4;

		// Token: 0x040058BF RID: 22719
		[Token(Token = "0x40058BF")]
		private const int Z_OK = 0;

		// Token: 0x040058C0 RID: 22720
		[Token(Token = "0x40058C0")]
		private const int Z_STREAM_END = 1;

		// Token: 0x040058C1 RID: 22721
		[Token(Token = "0x40058C1")]
		private const int Z_NEED_DICT = 2;

		// Token: 0x040058C2 RID: 22722
		[Token(Token = "0x40058C2")]
		private const int Z_ERRNO = -1;

		// Token: 0x040058C3 RID: 22723
		[Token(Token = "0x40058C3")]
		private const int Z_STREAM_ERROR = -2;

		// Token: 0x040058C4 RID: 22724
		[Token(Token = "0x40058C4")]
		private const int Z_DATA_ERROR = -3;

		// Token: 0x040058C5 RID: 22725
		[Token(Token = "0x40058C5")]
		private const int Z_MEM_ERROR = -4;

		// Token: 0x040058C6 RID: 22726
		[Token(Token = "0x40058C6")]
		private const int Z_BUF_ERROR = -5;

		// Token: 0x040058C7 RID: 22727
		[Token(Token = "0x40058C7")]
		private const int Z_VERSION_ERROR = -6;

		// Token: 0x040058C8 RID: 22728
		[Token(Token = "0x40058C8")]
		private const int INIT_STATE = 42;

		// Token: 0x040058C9 RID: 22729
		[Token(Token = "0x40058C9")]
		private const int BUSY_STATE = 113;

		// Token: 0x040058CA RID: 22730
		[Token(Token = "0x40058CA")]
		private const int FINISH_STATE = 666;

		// Token: 0x040058CB RID: 22731
		[Token(Token = "0x40058CB")]
		private const int Z_DEFLATED = 8;

		// Token: 0x040058CC RID: 22732
		[Token(Token = "0x40058CC")]
		private const int STORED_BLOCK = 0;

		// Token: 0x040058CD RID: 22733
		[Token(Token = "0x40058CD")]
		private const int STATIC_TREES = 1;

		// Token: 0x040058CE RID: 22734
		[Token(Token = "0x40058CE")]
		private const int DYN_TREES = 2;

		// Token: 0x040058CF RID: 22735
		[Token(Token = "0x40058CF")]
		private const int Z_BINARY = 0;

		// Token: 0x040058D0 RID: 22736
		[Token(Token = "0x40058D0")]
		private const int Z_ASCII = 1;

		// Token: 0x040058D1 RID: 22737
		[Token(Token = "0x40058D1")]
		private const int Z_UNKNOWN = 2;

		// Token: 0x040058D2 RID: 22738
		[Token(Token = "0x40058D2")]
		private const int Buf_size = 16;

		// Token: 0x040058D3 RID: 22739
		[Token(Token = "0x40058D3")]
		private const int REP_3_6 = 16;

		// Token: 0x040058D4 RID: 22740
		[Token(Token = "0x40058D4")]
		private const int REPZ_3_10 = 17;

		// Token: 0x040058D5 RID: 22741
		[Token(Token = "0x40058D5")]
		private const int REPZ_11_138 = 18;

		// Token: 0x040058D6 RID: 22742
		[Token(Token = "0x40058D6")]
		private const int MIN_MATCH = 3;

		// Token: 0x040058D7 RID: 22743
		[Token(Token = "0x40058D7")]
		private const int MAX_MATCH = 258;

		// Token: 0x040058D8 RID: 22744
		[Token(Token = "0x40058D8")]
		private const int MIN_LOOKAHEAD = 262;

		// Token: 0x040058D9 RID: 22745
		[Token(Token = "0x40058D9")]
		private const int MAX_BITS = 15;

		// Token: 0x040058DA RID: 22746
		[Token(Token = "0x40058DA")]
		private const int D_CODES = 30;

		// Token: 0x040058DB RID: 22747
		[Token(Token = "0x40058DB")]
		private const int BL_CODES = 19;

		// Token: 0x040058DC RID: 22748
		[Token(Token = "0x40058DC")]
		private const int LENGTH_CODES = 29;

		// Token: 0x040058DD RID: 22749
		[Token(Token = "0x40058DD")]
		private const int LITERALS = 256;

		// Token: 0x040058DE RID: 22750
		[Token(Token = "0x40058DE")]
		private const int L_CODES = 286;

		// Token: 0x040058DF RID: 22751
		[Token(Token = "0x40058DF")]
		private const int HEAP_SIZE = 573;

		// Token: 0x040058E0 RID: 22752
		[Token(Token = "0x40058E0")]
		private const int END_BLOCK = 256;

		// Token: 0x040058E1 RID: 22753
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
		[Token(Token = "0x40058E1")]
		internal ZStream strm;

		// Token: 0x040058E2 RID: 22754
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
		[Token(Token = "0x40058E2")]
		internal int status;

		// Token: 0x040058E3 RID: 22755
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
		[Token(Token = "0x40058E3")]
		internal byte[] pending_buf;

		// Token: 0x040058E4 RID: 22756
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
		[Token(Token = "0x40058E4")]
		internal int pending_buf_size;

		// Token: 0x040058E5 RID: 22757
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x2C")]
		[Token(Token = "0x40058E5")]
		internal int pending_out;

		// Token: 0x040058E6 RID: 22758
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
		[Token(Token = "0x40058E6")]
		internal int pending;

		// Token: 0x040058E7 RID: 22759
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x34")]
		[Token(Token = "0x40058E7")]
		internal int noheader;

		// Token: 0x040058E8 RID: 22760
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x38")]
		[Token(Token = "0x40058E8")]
		internal byte data_type;

		// Token: 0x040058E9 RID: 22761
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x39")]
		[Token(Token = "0x40058E9")]
		internal byte method;

		// Token: 0x040058EA RID: 22762
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x3C")]
		[Token(Token = "0x40058EA")]
		internal int last_flush;

		// Token: 0x040058EB RID: 22763
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x40")]
		[Token(Token = "0x40058EB")]
		internal int w_size;

		// Token: 0x040058EC RID: 22764
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x44")]
		[Token(Token = "0x40058EC")]
		internal int w_bits;

		// Token: 0x040058ED RID: 22765
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x48")]
		[Token(Token = "0x40058ED")]
		internal int w_mask;

		// Token: 0x040058EE RID: 22766
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x50")]
		[Token(Token = "0x40058EE")]
		internal byte[] window;

		// Token: 0x040058EF RID: 22767
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x58")]
		[Token(Token = "0x40058EF")]
		internal int window_size;

		// Token: 0x040058F0 RID: 22768
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x60")]
		[Token(Token = "0x40058F0")]
		internal short[] prev;

		// Token: 0x040058F1 RID: 22769
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x68")]
		[Token(Token = "0x40058F1")]
		internal short[] head;

		// Token: 0x040058F2 RID: 22770
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x70")]
		[Token(Token = "0x40058F2")]
		internal int ins_h;

		// Token: 0x040058F3 RID: 22771
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x74")]
		[Token(Token = "0x40058F3")]
		internal int hash_size;

		// Token: 0x040058F4 RID: 22772
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x78")]
		[Token(Token = "0x40058F4")]
		internal int hash_bits;

		// Token: 0x040058F5 RID: 22773
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x7C")]
		[Token(Token = "0x40058F5")]
		internal int hash_mask;

		// Token: 0x040058F6 RID: 22774
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x80")]
		[Token(Token = "0x40058F6")]
		internal int hash_shift;

		// Token: 0x040058F7 RID: 22775
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x84")]
		[Token(Token = "0x40058F7")]
		internal int block_start;

		// Token: 0x040058F8 RID: 22776
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x88")]
		[Token(Token = "0x40058F8")]
		internal int match_length;

		// Token: 0x040058F9 RID: 22777
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x8C")]
		[Token(Token = "0x40058F9")]
		internal int prev_match;

		// Token: 0x040058FA RID: 22778
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x90")]
		[Token(Token = "0x40058FA")]
		internal int match_available;

		// Token: 0x040058FB RID: 22779
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x94")]
		[Token(Token = "0x40058FB")]
		internal int strstart;

		// Token: 0x040058FC RID: 22780
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x98")]
		[Token(Token = "0x40058FC")]
		internal int match_start;

		// Token: 0x040058FD RID: 22781
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x9C")]
		[Token(Token = "0x40058FD")]
		internal int lookahead;

		// Token: 0x040058FE RID: 22782
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xA0")]
		[Token(Token = "0x40058FE")]
		internal int prev_length;

		// Token: 0x040058FF RID: 22783
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xA4")]
		[Token(Token = "0x40058FF")]
		internal int max_chain_length;

		// Token: 0x04005900 RID: 22784
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xA8")]
		[Token(Token = "0x4005900")]
		internal int max_lazy_match;

		// Token: 0x04005901 RID: 22785
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xAC")]
		[Token(Token = "0x4005901")]
		internal int level;

		// Token: 0x04005902 RID: 22786
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xB0")]
		[Token(Token = "0x4005902")]
		internal int strategy;

		// Token: 0x04005903 RID: 22787
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xB4")]
		[Token(Token = "0x4005903")]
		internal int good_match;

		// Token: 0x04005904 RID: 22788
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xB8")]
		[Token(Token = "0x4005904")]
		internal int nice_match;

		// Token: 0x04005905 RID: 22789
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xC0")]
		[Token(Token = "0x4005905")]
		internal short[] dyn_ltree;

		// Token: 0x04005906 RID: 22790
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xC8")]
		[Token(Token = "0x4005906")]
		internal short[] dyn_dtree;

		// Token: 0x04005907 RID: 22791
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xD0")]
		[Token(Token = "0x4005907")]
		internal short[] bl_tree;

		// Token: 0x04005908 RID: 22792
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xD8")]
		[Token(Token = "0x4005908")]
		internal ZTree l_desc;

		// Token: 0x04005909 RID: 22793
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xE0")]
		[Token(Token = "0x4005909")]
		internal ZTree d_desc;

		// Token: 0x0400590A RID: 22794
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xE8")]
		[Token(Token = "0x400590A")]
		internal ZTree bl_desc;

		// Token: 0x0400590B RID: 22795
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xF0")]
		[Token(Token = "0x400590B")]
		internal short[] bl_count;

		// Token: 0x0400590C RID: 22796
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xF8")]
		[Token(Token = "0x400590C")]
		internal int[] heap;

		// Token: 0x0400590D RID: 22797
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x100")]
		[Token(Token = "0x400590D")]
		internal int heap_len;

		// Token: 0x0400590E RID: 22798
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x104")]
		[Token(Token = "0x400590E")]
		internal int heap_max;

		// Token: 0x0400590F RID: 22799
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x108")]
		[Token(Token = "0x400590F")]
		internal byte[] depth;

		// Token: 0x04005910 RID: 22800
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x110")]
		[Token(Token = "0x4005910")]
		internal int l_buf;

		// Token: 0x04005911 RID: 22801
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x114")]
		[Token(Token = "0x4005911")]
		internal int lit_bufsize;

		// Token: 0x04005912 RID: 22802
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x118")]
		[Token(Token = "0x4005912")]
		internal int last_lit;

		// Token: 0x04005913 RID: 22803
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x11C")]
		[Token(Token = "0x4005913")]
		internal int d_buf;

		// Token: 0x04005914 RID: 22804
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x120")]
		[Token(Token = "0x4005914")]
		internal int opt_len;

		// Token: 0x04005915 RID: 22805
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x124")]
		[Token(Token = "0x4005915")]
		internal int static_len;

		// Token: 0x04005916 RID: 22806
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x128")]
		[Token(Token = "0x4005916")]
		internal int matches;

		// Token: 0x04005917 RID: 22807
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x12C")]
		[Token(Token = "0x4005917")]
		internal int last_eob_len;

		// Token: 0x04005918 RID: 22808
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x130")]
		[Token(Token = "0x4005918")]
		internal uint bi_buf;

		// Token: 0x04005919 RID: 22809
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x134")]
		[Token(Token = "0x4005919")]
		internal int bi_valid;

		// Token: 0x0200134E RID: 4942
		[Token(Token = "0x200134E")]
		internal class Config
		{
			// Token: 0x06007CC8 RID: 31944 RVA: 0x001A10C0 File Offset: 0x0019F2C0
			[Token(Token = "0x6007CC8")]
			[Address(RVA = "0xE250B0", Offset = "0xE23AB0", VA = "0x180E250B0")]
			internal Config(int good_length, int max_lazy, int nice_length, int max_chain, int func)
			{
				this.max_chain = 0;
				this.good_length = good_length;
				this.nice_length = nice_length;
				this.func = 0;
				this.max_lazy = max_lazy;
			}

			// Token: 0x0400591A RID: 22810
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
			[Token(Token = "0x400591A")]
			internal int good_length;

			// Token: 0x0400591B RID: 22811
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x14")]
			[Token(Token = "0x400591B")]
			internal int max_lazy;

			// Token: 0x0400591C RID: 22812
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
			[Token(Token = "0x400591C")]
			internal int nice_length;

			// Token: 0x0400591D RID: 22813
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x1C")]
			[Token(Token = "0x400591D")]
			internal int max_chain;

			// Token: 0x0400591E RID: 22814
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
			[Token(Token = "0x400591E")]
			internal int func;
		}
	}
}