27Aug2021-Cpp2IL-Dump/Assembly-CSharp/BestHTTP/SecureProtocol/Org/BouncyCastle/Utilities/Zlib/Deflate.cs

using System;
using Cpp2IlInjected;

namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.Zlib
{
	// Token: 0x02001A0A RID: 6666
	[Token(Token = "0x2001A0A")]
	public sealed class Deflate
	{
		// Token: 0x06009C48 RID: 40008 RVA: 0x001FF6B4 File Offset: 0x001FD8B4
		[Token(Token = "0x6009C48")]
		[Address(RVA = "0x4E13F0", Offset = "0x4E03F0", VA = "0x1804E13F0")]
		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: 0x06009C49 RID: 40009 RVA: 0x001FFA60 File Offset: 0x001FDC60
		[Token(Token = "0x6009C49")]
		[Address(RVA = "0x4E1DF0", Offset = "0x4E0DF0", VA = "0x1804E1DF0")]
		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: 0x06009C4A RID: 40010 RVA: 0x001FFB08 File Offset: 0x001FDD08
		[Token(Token = "0x6009C4A")]
		[Address(RVA = "0x4E51D0", Offset = "0x4E41D0", VA = "0x1804E51D0")]
		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: 0x06009C4B RID: 40011 RVA: 0x001FFC14 File Offset: 0x001FDE14
		[Token(Token = "0x6009C4B")]
		[Address(RVA = "0x4E6710", Offset = "0x4E5710", VA = "0x1804E6710")]
		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: 0x06009C4C RID: 40012 RVA: 0x001FFCCC File Offset: 0x001FDECC
		[Token(Token = "0x6009C4C")]
		[Address(RVA = "0x4E50A0", Offset = "0x4E40A0", VA = "0x1804E50A0")]
		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: 0x06009C4D RID: 40013 RVA: 0x001FFD44 File Offset: 0x001FDF44
		[Token(Token = "0x6009C4D")]
		[Address(RVA = "0x4E5A20", Offset = "0x4E4A20", VA = "0x1804E5A20")]
		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: 0x06009C4E RID: 40014 RVA: 0x001FFDE8 File Offset: 0x001FDFE8
		[Token(Token = "0x6009C4E")]
		[Address(RVA = "0x4E6650", Offset = "0x4E5650", VA = "0x1804E6650")]
		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: 0x06009C4F RID: 40015 RVA: 0x001FFE18 File Offset: 0x001FE018
		[Token(Token = "0x6009C4F")]
		[Address(RVA = "0x4E5E10", Offset = "0x4E4E10", VA = "0x1804E5E10")]
		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: 0x06009C50 RID: 40016 RVA: 0x001FFE88 File Offset: 0x001FE088
		[Token(Token = "0x6009C50")]
		[Address(RVA = "0x4E2B90", Offset = "0x4E1B90", VA = "0x1804E2B90")]
		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: 0x06009C51 RID: 40017 RVA: 0x001FFF04 File Offset: 0x001FE104
		[Token(Token = "0x6009C51")]
		[Address(RVA = "0x4E6070", Offset = "0x4E5070", VA = "0x1804E6070")]
		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: 0x06009C52 RID: 40018 RVA: 0x001FFF70 File Offset: 0x001FE170
		[Token(Token = "0x6009C52")]
		[Address(RVA = "0x4E6350", Offset = "0x4E5350", VA = "0x1804E6350")]
		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: 0x06009C53 RID: 40019 RVA: 0x00200014 File Offset: 0x001FE214
		[Token(Token = "0x6009C53")]
		[Address(RVA = "0x4E5D00", Offset = "0x4E4D00", VA = "0x1804E5D00")]
		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: 0x06009C54 RID: 40020 RVA: 0x0020003C File Offset: 0x001FE23C
		[Token(Token = "0x6009C54")]
		[Address(RVA = "0x4E5D50", Offset = "0x4E4D50", VA = "0x1804E5D50")]
		internal void put_byte(byte c)
		{
			int num = this.pending;
			byte[] array = this.pending_buf;
			int num2 = num + 1;
			this.pending = num2;
		}

		// Token: 0x06009C55 RID: 40021 RVA: 0x00200068 File Offset: 0x001FE268
		[Token(Token = "0x6009C55")]
		[Address(RVA = "0x4E5D90", Offset = "0x4E4D90", VA = "0x1804E5D90")]
		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: 0x06009C56 RID: 40022 RVA: 0x002000B0 File Offset: 0x001FE2B0
		[Token(Token = "0x6009C56")]
		[Address(RVA = "0x4E5C80", Offset = "0x4E4C80", VA = "0x1804E5C80")]
		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: 0x06009C57 RID: 40023 RVA: 0x002000F8 File Offset: 0x001FE2F8
		[Token(Token = "0x6009C57")]
		[Address(RVA = "0x4E62E0", Offset = "0x4E52E0", VA = "0x1804E62E0")]
		internal void send_code(int c, short[] tree)
		{
			int length = tree.Length;
			short num;
			short num2;
			this.send_bits((int)num, (int)num2);
		}

		// Token: 0x06009C58 RID: 40024 RVA: 0x0020011C File Offset: 0x001FE31C
		[Token(Token = "0x6009C58")]
		[Address(RVA = "0x4E61F0", Offset = "0x4E51F0", VA = "0x1804E61F0")]
		internal void send_bits(int val, int length)
		{
			int num = this.bi_valid;
			uint num2;
			num2 -= (uint)length;
			this.bi_buf = (uint)val;
		}

		// Token: 0x06009C59 RID: 40025 RVA: 0x002001A8 File Offset: 0x001FE3A8
		[Token(Token = "0x6009C59")]
		[Address(RVA = "0x4E1F20", Offset = "0x4E0F20", VA = "0x1804E1F20")]
		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: 0x06009C5A RID: 40026 RVA: 0x00200258 File Offset: 0x001FE458
		[Token(Token = "0x6009C5A")]
		[Address(RVA = "0x4E2680", Offset = "0x4E1680", VA = "0x1804E2680")]
		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: 0x06009C5B RID: 40027 RVA: 0x0020034C File Offset: 0x001FE54C
		[Token(Token = "0x6009C5B")]
		[Address(RVA = "0x4E2CF0", Offset = "0x4E1CF0", VA = "0x1804E2CF0")]
		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: 0x06009C5C RID: 40028 RVA: 0x00200480 File Offset: 0x001FE680
		[Token(Token = "0x6009C5C")]
		[Address(RVA = "0x4E6550", Offset = "0x4E5550", VA = "0x1804E6550")]
		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: 0x06009C5D RID: 40029 RVA: 0x002004DC File Offset: 0x001FE6DC
		[Token(Token = "0x6009C5D")]
		[Address(RVA = "0x4E29C0", Offset = "0x4E19C0", VA = "0x1804E29C0")]
		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: 0x06009C5E RID: 40030 RVA: 0x00200578 File Offset: 0x001FE778
		[Token(Token = "0x6009C5E")]
		[Address(RVA = "0x4E2AB0", Offset = "0x4E1AB0", VA = "0x1804E2AB0")]
		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: 0x06009C5F RID: 40031 RVA: 0x00200618 File Offset: 0x001FE818
		[Token(Token = "0x6009C5F")]
		[Address(RVA = "0x4E31A0", Offset = "0x4E21A0", VA = "0x1804E31A0")]
		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: 0x06009C60 RID: 40032 RVA: 0x00200668 File Offset: 0x001FE868
		[Token(Token = "0x6009C60")]
		[Address(RVA = "0x4E5040", Offset = "0x4E4040", VA = "0x1804E5040")]
		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: 0x06009C61 RID: 40033 RVA: 0x002006B4 File Offset: 0x001FE8B4
		[Token(Token = "0x6009C61")]
		[Address(RVA = "0x4E4C30", Offset = "0x4E3C30", VA = "0x1804E4C30")]
		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: 0x06009C62 RID: 40034 RVA: 0x002007F0 File Offset: 0x001FE9F0
		[Token(Token = "0x6009C62")]
		[Address(RVA = "0x4E25E0", Offset = "0x4E15E0", VA = "0x1804E25E0")]
		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: 0x06009C63 RID: 40035 RVA: 0x00200848 File Offset: 0x001FEA48
		[Token(Token = "0x6009C63")]
		[Address(RVA = "0x4E20C0", Offset = "0x4E10C0", VA = "0x1804E20C0")]
		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: 0x06009C64 RID: 40036 RVA: 0x00200A0C File Offset: 0x001FEC0C
		[Token(Token = "0x6009C64")]
		[Address(RVA = "0x4E4DE0", Offset = "0x4E3DE0", VA = "0x1804E4DE0")]
		internal void fill_window()
		{
			int num2;
			int num18;
			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;
				if (zstream.avail_in == num2)
				{
					break;
				}
				int num15 = this.lookahead;
				byte[] array4 = this.window;
				uint num17;
				int num16 = zstream.read_buf(array4, num15, (int)num17);
				num18 = this.lookahead;
				byte[] array5 = this.window;
				num13 = this.strstart;
				byte b;
				this.ins_h = (int)b;
				num13++;
				this.ins_h = (int)b;
			}
			while (num18 < 262 && this.strm.avail_in != num2);
		}

		// Token: 0x06009C65 RID: 40037 RVA: 0x00200B7C File Offset: 0x001FED7C
		[Token(Token = "0x6009C65")]
		[Address(RVA = "0x4E3CC0", Offset = "0x4E2CC0", VA = "0x1804E3CC0")]
		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: 0x06009C66 RID: 40038 RVA: 0x00200E64 File Offset: 0x001FF064
		[Token(Token = "0x6009C66")]
		[Address(RVA = "0x4E46B0", Offset = "0x4E36B0", VA = "0x1804E46B0")]
		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: 0x06009C67 RID: 40039 RVA: 0x00201138 File Offset: 0x001FF338
		[Token(Token = "0x6009C67")]
		[Address(RVA = "0x4E5400", Offset = "0x4E4400", VA = "0x1804E5400")]
		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: 0x06009C68 RID: 40040 RVA: 0x00201264 File Offset: 0x001FF464
		[Token(Token = "0x6009C68")]
		[Address(RVA = "0x4E35F0", Offset = "0x4E25F0", VA = "0x1804E35F0")]
		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: 0x06009C69 RID: 40041 RVA: 0x00201280 File Offset: 0x001FF480
		[Token(Token = "0x6009C69")]
		[Address(RVA = "0x4E35C0", Offset = "0x4E25C0", VA = "0x1804E35C0")]
		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: 0x06009C6A RID: 40042 RVA: 0x0020129C File Offset: 0x001FF49C
		[Token(Token = "0x6009C6A")]
		[Address(RVA = "0x4E3270", Offset = "0x4E2270", VA = "0x1804E3270")]
		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: 0x06009C6B RID: 40043 RVA: 0x0020149C File Offset: 0x001FF69C
		[Token(Token = "0x6009C6B")]
		[Address(RVA = "0x4E38E0", Offset = "0x4E28E0", VA = "0x1804E38E0")]
		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: 0x06009C6C RID: 40044 RVA: 0x002015AC File Offset: 0x001FF7AC
		[Token(Token = "0x6009C6C")]
		[Address(RVA = "0x4E3230", Offset = "0x4E2230", VA = "0x1804E3230")]
		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: 0x06009C6D RID: 40045 RVA: 0x002015F8 File Offset: 0x001FF7F8
		[Token(Token = "0x6009C6D")]
		[Address(RVA = "0x4E3620", Offset = "0x4E2620", VA = "0x1804E3620")]
		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)
				{
					int num3 = strm.deflate(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: 0x06009C6E RID: 40046 RVA: 0x002016F0 File Offset: 0x001FF8F0
		[Token(Token = "0x6009C6E")]
		[Address(RVA = "0x4E3A80", Offset = "0x4E2A80", VA = "0x1804E3A80")]
		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: 0x06009C6F RID: 40047 RVA: 0x00201800 File Offset: 0x001FFA00
		[Token(Token = "0x6009C6F")]
		[Address(RVA = "0x4E41C0", Offset = "0x4E31C0", VA = "0x1804E41C0")]
		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: 0x040068A5 RID: 26789
		[Token(Token = "0x40068A5")]
		private const int MAX_MEM_LEVEL = 9;

		// Token: 0x040068A6 RID: 26790
		[Token(Token = "0x40068A6")]
		private const int Z_DEFAULT_COMPRESSION = -1;

		// Token: 0x040068A7 RID: 26791
		[Token(Token = "0x40068A7")]
		private const int MAX_WBITS = 15;

		// Token: 0x040068A8 RID: 26792
		[Token(Token = "0x40068A8")]
		private const int DEF_MEM_LEVEL = 8;

		// Token: 0x040068A9 RID: 26793
		[Token(Token = "0x40068A9")]
		private const int STORED = 0;

		// Token: 0x040068AA RID: 26794
		[Token(Token = "0x40068AA")]
		private const int FAST = 1;

		// Token: 0x040068AB RID: 26795
		[Token(Token = "0x40068AB")]
		private const int SLOW = 2;

		// Token: 0x040068AC RID: 26796
		[Token(Token = "0x40068AC")]
		private static readonly Deflate.Config[] config_table;

		// Token: 0x040068AD RID: 26797
		[Token(Token = "0x40068AD")]
		private static readonly string[] z_errmsg;

		// Token: 0x040068AE RID: 26798
		[Token(Token = "0x40068AE")]
		private const int NeedMore = 0;

		// Token: 0x040068AF RID: 26799
		[Token(Token = "0x40068AF")]
		private const int BlockDone = 1;

		// Token: 0x040068B0 RID: 26800
		[Token(Token = "0x40068B0")]
		private const int FinishStarted = 2;

		// Token: 0x040068B1 RID: 26801
		[Token(Token = "0x40068B1")]
		private const int FinishDone = 3;

		// Token: 0x040068B2 RID: 26802
		[Token(Token = "0x40068B2")]
		private const int PRESET_DICT = 32;

		// Token: 0x040068B3 RID: 26803
		[Token(Token = "0x40068B3")]
		private const int Z_FILTERED = 1;

		// Token: 0x040068B4 RID: 26804
		[Token(Token = "0x40068B4")]
		private const int Z_HUFFMAN_ONLY = 2;

		// Token: 0x040068B5 RID: 26805
		[Token(Token = "0x40068B5")]
		private const int Z_DEFAULT_STRATEGY = 0;

		// Token: 0x040068B6 RID: 26806
		[Token(Token = "0x40068B6")]
		private const int Z_NO_FLUSH = 0;

		// Token: 0x040068B7 RID: 26807
		[Token(Token = "0x40068B7")]
		private const int Z_PARTIAL_FLUSH = 1;

		// Token: 0x040068B8 RID: 26808
		[Token(Token = "0x40068B8")]
		private const int Z_SYNC_FLUSH = 2;

		// Token: 0x040068B9 RID: 26809
		[Token(Token = "0x40068B9")]
		private const int Z_FULL_FLUSH = 3;

		// Token: 0x040068BA RID: 26810
		[Token(Token = "0x40068BA")]
		private const int Z_FINISH = 4;

		// Token: 0x040068BB RID: 26811
		[Token(Token = "0x40068BB")]
		private const int Z_OK = 0;

		// Token: 0x040068BC RID: 26812
		[Token(Token = "0x40068BC")]
		private const int Z_STREAM_END = 1;

		// Token: 0x040068BD RID: 26813
		[Token(Token = "0x40068BD")]
		private const int Z_NEED_DICT = 2;

		// Token: 0x040068BE RID: 26814
		[Token(Token = "0x40068BE")]
		private const int Z_ERRNO = -1;

		// Token: 0x040068BF RID: 26815
		[Token(Token = "0x40068BF")]
		private const int Z_STREAM_ERROR = -2;

		// Token: 0x040068C0 RID: 26816
		[Token(Token = "0x40068C0")]
		private const int Z_DATA_ERROR = -3;

		// Token: 0x040068C1 RID: 26817
		[Token(Token = "0x40068C1")]
		private const int Z_MEM_ERROR = -4;

		// Token: 0x040068C2 RID: 26818
		[Token(Token = "0x40068C2")]
		private const int Z_BUF_ERROR = -5;

		// Token: 0x040068C3 RID: 26819
		[Token(Token = "0x40068C3")]
		private const int Z_VERSION_ERROR = -6;

		// Token: 0x040068C4 RID: 26820
		[Token(Token = "0x40068C4")]
		private const int INIT_STATE = 42;

		// Token: 0x040068C5 RID: 26821
		[Token(Token = "0x40068C5")]
		private const int BUSY_STATE = 113;

		// Token: 0x040068C6 RID: 26822
		[Token(Token = "0x40068C6")]
		private const int FINISH_STATE = 666;

		// Token: 0x040068C7 RID: 26823
		[Token(Token = "0x40068C7")]
		private const int Z_DEFLATED = 8;

		// Token: 0x040068C8 RID: 26824
		[Token(Token = "0x40068C8")]
		private const int STORED_BLOCK = 0;

		// Token: 0x040068C9 RID: 26825
		[Token(Token = "0x40068C9")]
		private const int STATIC_TREES = 1;

		// Token: 0x040068CA RID: 26826
		[Token(Token = "0x40068CA")]
		private const int DYN_TREES = 2;

		// Token: 0x040068CB RID: 26827
		[Token(Token = "0x40068CB")]
		private const int Z_BINARY = 0;

		// Token: 0x040068CC RID: 26828
		[Token(Token = "0x40068CC")]
		private const int Z_ASCII = 1;

		// Token: 0x040068CD RID: 26829
		[Token(Token = "0x40068CD")]
		private const int Z_UNKNOWN = 2;

		// Token: 0x040068CE RID: 26830
		[Token(Token = "0x40068CE")]
		private const int Buf_size = 16;

		// Token: 0x040068CF RID: 26831
		[Token(Token = "0x40068CF")]
		private const int REP_3_6 = 16;

		// Token: 0x040068D0 RID: 26832
		[Token(Token = "0x40068D0")]
		private const int REPZ_3_10 = 17;

		// Token: 0x040068D1 RID: 26833
		[Token(Token = "0x40068D1")]
		private const int REPZ_11_138 = 18;

		// Token: 0x040068D2 RID: 26834
		[Token(Token = "0x40068D2")]
		private const int MIN_MATCH = 3;

		// Token: 0x040068D3 RID: 26835
		[Token(Token = "0x40068D3")]
		private const int MAX_MATCH = 258;

		// Token: 0x040068D4 RID: 26836
		[Token(Token = "0x40068D4")]
		private const int MIN_LOOKAHEAD = 262;

		// Token: 0x040068D5 RID: 26837
		[Token(Token = "0x40068D5")]
		private const int MAX_BITS = 15;

		// Token: 0x040068D6 RID: 26838
		[Token(Token = "0x40068D6")]
		private const int D_CODES = 30;

		// Token: 0x040068D7 RID: 26839
		[Token(Token = "0x40068D7")]
		private const int BL_CODES = 19;

		// Token: 0x040068D8 RID: 26840
		[Token(Token = "0x40068D8")]
		private const int LENGTH_CODES = 29;

		// Token: 0x040068D9 RID: 26841
		[Token(Token = "0x40068D9")]
		private const int LITERALS = 256;

		// Token: 0x040068DA RID: 26842
		[Token(Token = "0x40068DA")]
		private const int L_CODES = 286;

		// Token: 0x040068DB RID: 26843
		[Token(Token = "0x40068DB")]
		private const int HEAP_SIZE = 573;

		// Token: 0x040068DC RID: 26844
		[Token(Token = "0x40068DC")]
		private const int END_BLOCK = 256;

		// Token: 0x040068DD RID: 26845
		[FieldOffset(Offset = "0x10")]
		[Token(Token = "0x40068DD")]
		internal ZStream strm;

		// Token: 0x040068DE RID: 26846
		[FieldOffset(Offset = "0x18")]
		[Token(Token = "0x40068DE")]
		internal int status;

		// Token: 0x040068DF RID: 26847
		[FieldOffset(Offset = "0x20")]
		[Token(Token = "0x40068DF")]
		internal byte[] pending_buf;

		// Token: 0x040068E0 RID: 26848
		[FieldOffset(Offset = "0x28")]
		[Token(Token = "0x40068E0")]
		internal int pending_buf_size;

		// Token: 0x040068E1 RID: 26849
		[FieldOffset(Offset = "0x2C")]
		[Token(Token = "0x40068E1")]
		internal int pending_out;

		// Token: 0x040068E2 RID: 26850
		[FieldOffset(Offset = "0x30")]
		[Token(Token = "0x40068E2")]
		internal int pending;

		// Token: 0x040068E3 RID: 26851
		[FieldOffset(Offset = "0x34")]
		[Token(Token = "0x40068E3")]
		internal int noheader;

		// Token: 0x040068E4 RID: 26852
		[FieldOffset(Offset = "0x38")]
		[Token(Token = "0x40068E4")]
		internal byte data_type;

		// Token: 0x040068E5 RID: 26853
		[FieldOffset(Offset = "0x39")]
		[Token(Token = "0x40068E5")]
		internal byte method;

		// Token: 0x040068E6 RID: 26854
		[FieldOffset(Offset = "0x3C")]
		[Token(Token = "0x40068E6")]
		internal int last_flush;

		// Token: 0x040068E7 RID: 26855
		[FieldOffset(Offset = "0x40")]
		[Token(Token = "0x40068E7")]
		internal int w_size;

		// Token: 0x040068E8 RID: 26856
		[FieldOffset(Offset = "0x44")]
		[Token(Token = "0x40068E8")]
		internal int w_bits;

		// Token: 0x040068E9 RID: 26857
		[FieldOffset(Offset = "0x48")]
		[Token(Token = "0x40068E9")]
		internal int w_mask;

		// Token: 0x040068EA RID: 26858
		[FieldOffset(Offset = "0x50")]
		[Token(Token = "0x40068EA")]
		internal byte[] window;

		// Token: 0x040068EB RID: 26859
		[FieldOffset(Offset = "0x58")]
		[Token(Token = "0x40068EB")]
		internal int window_size;

		// Token: 0x040068EC RID: 26860
		[FieldOffset(Offset = "0x60")]
		[Token(Token = "0x40068EC")]
		internal short[] prev;

		// Token: 0x040068ED RID: 26861
		[FieldOffset(Offset = "0x68")]
		[Token(Token = "0x40068ED")]
		internal short[] head;

		// Token: 0x040068EE RID: 26862
		[FieldOffset(Offset = "0x70")]
		[Token(Token = "0x40068EE")]
		internal int ins_h;

		// Token: 0x040068EF RID: 26863
		[FieldOffset(Offset = "0x74")]
		[Token(Token = "0x40068EF")]
		internal int hash_size;

		// Token: 0x040068F0 RID: 26864
		[FieldOffset(Offset = "0x78")]
		[Token(Token = "0x40068F0")]
		internal int hash_bits;

		// Token: 0x040068F1 RID: 26865
		[FieldOffset(Offset = "0x7C")]
		[Token(Token = "0x40068F1")]
		internal int hash_mask;

		// Token: 0x040068F2 RID: 26866
		[FieldOffset(Offset = "0x80")]
		[Token(Token = "0x40068F2")]
		internal int hash_shift;

		// Token: 0x040068F3 RID: 26867
		[FieldOffset(Offset = "0x84")]
		[Token(Token = "0x40068F3")]
		internal int block_start;

		// Token: 0x040068F4 RID: 26868
		[FieldOffset(Offset = "0x88")]
		[Token(Token = "0x40068F4")]
		internal int match_length;

		// Token: 0x040068F5 RID: 26869
		[FieldOffset(Offset = "0x8C")]
		[Token(Token = "0x40068F5")]
		internal int prev_match;

		// Token: 0x040068F6 RID: 26870
		[FieldOffset(Offset = "0x90")]
		[Token(Token = "0x40068F6")]
		internal int match_available;

		// Token: 0x040068F7 RID: 26871
		[FieldOffset(Offset = "0x94")]
		[Token(Token = "0x40068F7")]
		internal int strstart;

		// Token: 0x040068F8 RID: 26872
		[FieldOffset(Offset = "0x98")]
		[Token(Token = "0x40068F8")]
		internal int match_start;

		// Token: 0x040068F9 RID: 26873
		[FieldOffset(Offset = "0x9C")]
		[Token(Token = "0x40068F9")]
		internal int lookahead;

		// Token: 0x040068FA RID: 26874
		[FieldOffset(Offset = "0xA0")]
		[Token(Token = "0x40068FA")]
		internal int prev_length;

		// Token: 0x040068FB RID: 26875
		[FieldOffset(Offset = "0xA4")]
		[Token(Token = "0x40068FB")]
		internal int max_chain_length;

		// Token: 0x040068FC RID: 26876
		[FieldOffset(Offset = "0xA8")]
		[Token(Token = "0x40068FC")]
		internal int max_lazy_match;

		// Token: 0x040068FD RID: 26877
		[FieldOffset(Offset = "0xAC")]
		[Token(Token = "0x40068FD")]
		internal int level;

		// Token: 0x040068FE RID: 26878
		[FieldOffset(Offset = "0xB0")]
		[Token(Token = "0x40068FE")]
		internal int strategy;

		// Token: 0x040068FF RID: 26879
		[FieldOffset(Offset = "0xB4")]
		[Token(Token = "0x40068FF")]
		internal int good_match;

		// Token: 0x04006900 RID: 26880
		[FieldOffset(Offset = "0xB8")]
		[Token(Token = "0x4006900")]
		internal int nice_match;

		// Token: 0x04006901 RID: 26881
		[FieldOffset(Offset = "0xC0")]
		[Token(Token = "0x4006901")]
		internal short[] dyn_ltree;

		// Token: 0x04006902 RID: 26882
		[FieldOffset(Offset = "0xC8")]
		[Token(Token = "0x4006902")]
		internal short[] dyn_dtree;

		// Token: 0x04006903 RID: 26883
		[FieldOffset(Offset = "0xD0")]
		[Token(Token = "0x4006903")]
		internal short[] bl_tree;

		// Token: 0x04006904 RID: 26884
		[FieldOffset(Offset = "0xD8")]
		[Token(Token = "0x4006904")]
		internal ZTree l_desc;

		// Token: 0x04006905 RID: 26885
		[FieldOffset(Offset = "0xE0")]
		[Token(Token = "0x4006905")]
		internal ZTree d_desc;

		// Token: 0x04006906 RID: 26886
		[FieldOffset(Offset = "0xE8")]
		[Token(Token = "0x4006906")]
		internal ZTree bl_desc;

		// Token: 0x04006907 RID: 26887
		[FieldOffset(Offset = "0xF0")]
		[Token(Token = "0x4006907")]
		internal short[] bl_count;

		// Token: 0x04006908 RID: 26888
		[FieldOffset(Offset = "0xF8")]
		[Token(Token = "0x4006908")]
		internal int[] heap;

		// Token: 0x04006909 RID: 26889
		[FieldOffset(Offset = "0x100")]
		[Token(Token = "0x4006909")]
		internal int heap_len;

		// Token: 0x0400690A RID: 26890
		[FieldOffset(Offset = "0x104")]
		[Token(Token = "0x400690A")]
		internal int heap_max;

		// Token: 0x0400690B RID: 26891
		[FieldOffset(Offset = "0x108")]
		[Token(Token = "0x400690B")]
		internal byte[] depth;

		// Token: 0x0400690C RID: 26892
		[FieldOffset(Offset = "0x110")]
		[Token(Token = "0x400690C")]
		internal int l_buf;

		// Token: 0x0400690D RID: 26893
		[FieldOffset(Offset = "0x114")]
		[Token(Token = "0x400690D")]
		internal int lit_bufsize;

		// Token: 0x0400690E RID: 26894
		[FieldOffset(Offset = "0x118")]
		[Token(Token = "0x400690E")]
		internal int last_lit;

		// Token: 0x0400690F RID: 26895
		[FieldOffset(Offset = "0x11C")]
		[Token(Token = "0x400690F")]
		internal int d_buf;

		// Token: 0x04006910 RID: 26896
		[FieldOffset(Offset = "0x120")]
		[Token(Token = "0x4006910")]
		internal int opt_len;

		// Token: 0x04006911 RID: 26897
		[FieldOffset(Offset = "0x124")]
		[Token(Token = "0x4006911")]
		internal int static_len;

		// Token: 0x04006912 RID: 26898
		[FieldOffset(Offset = "0x128")]
		[Token(Token = "0x4006912")]
		internal int matches;

		// Token: 0x04006913 RID: 26899
		[FieldOffset(Offset = "0x12C")]
		[Token(Token = "0x4006913")]
		internal int last_eob_len;

		// Token: 0x04006914 RID: 26900
		[FieldOffset(Offset = "0x130")]
		[Token(Token = "0x4006914")]
		internal uint bi_buf;

		// Token: 0x04006915 RID: 26901
		[FieldOffset(Offset = "0x134")]
		[Token(Token = "0x4006915")]
		internal int bi_valid;

		// Token: 0x02001A0B RID: 6667
		[Token(Token = "0x2001A0B")]
		internal class Config
		{
			// Token: 0x06009C70 RID: 40048 RVA: 0x00201A98 File Offset: 0x001FFC98
			[Token(Token = "0x6009C70")]
			[Address(RVA = "0x4E0F80", Offset = "0x4DFF80", VA = "0x1804E0F80")]
			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: 0x04006916 RID: 26902
			[FieldOffset(Offset = "0x10")]
			[Token(Token = "0x4006916")]
			internal int good_length;

			// Token: 0x04006917 RID: 26903
			[FieldOffset(Offset = "0x14")]
			[Token(Token = "0x4006917")]
			internal int max_lazy;

			// Token: 0x04006918 RID: 26904
			[FieldOffset(Offset = "0x18")]
			[Token(Token = "0x4006918")]
			internal int nice_length;

			// Token: 0x04006919 RID: 26905
			[FieldOffset(Offset = "0x1C")]
			[Token(Token = "0x4006919")]
			internal int max_chain;

			// Token: 0x0400691A RID: 26906
			[FieldOffset(Offset = "0x20")]
			[Token(Token = "0x400691A")]
			internal int func;
		}
	}
}