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

using System;
using Cpp2IlInjected;

namespace BestHTTP.SecureProtocol.Org.BouncyCastle.Utilities.Zlib
{
	// Token: 0x0200192A RID: 6442
	[Token(Token = "0x200192A")]
	public sealed class Deflate
	{
		// Token: 0x0600987A RID: 39034 RVA: 0x001F661C File Offset: 0x001F481C
		[Token(Token = "0x600987A")]
		[Address(RVA = "0x18D78E0", Offset = "0x18D66E0", VA = "0x1818D78E0")]
		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: 0x0600987B RID: 39035 RVA: 0x001F69C8 File Offset: 0x001F4BC8
		[Token(Token = "0x600987B")]
		[Address(RVA = "0x18D82E0", Offset = "0x18D70E0", VA = "0x1818D82E0")]
		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: 0x0600987C RID: 39036 RVA: 0x001F6A70 File Offset: 0x001F4C70
		[Token(Token = "0x600987C")]
		[Address(RVA = "0x18DB6C0", Offset = "0x18DA4C0", VA = "0x1818DB6C0")]
		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: 0x0600987D RID: 39037 RVA: 0x001F6B7C File Offset: 0x001F4D7C
		[Token(Token = "0x600987D")]
		[Address(RVA = "0x18DCC00", Offset = "0x18DBA00", VA = "0x1818DCC00")]
		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: 0x0600987E RID: 39038 RVA: 0x001F6C34 File Offset: 0x001F4E34
		[Token(Token = "0x600987E")]
		[Address(RVA = "0x18DB590", Offset = "0x18DA390", VA = "0x1818DB590")]
		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: 0x0600987F RID: 39039 RVA: 0x001F6CAC File Offset: 0x001F4EAC
		[Token(Token = "0x600987F")]
		[Address(RVA = "0x18DBF10", Offset = "0x18DAD10", VA = "0x1818DBF10")]
		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: 0x06009880 RID: 39040 RVA: 0x001F6D50 File Offset: 0x001F4F50
		[Token(Token = "0x6009880")]
		[Address(RVA = "0x18DCB40", Offset = "0x18DB940", VA = "0x1818DCB40")]
		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: 0x06009881 RID: 39041 RVA: 0x001F6D80 File Offset: 0x001F4F80
		[Token(Token = "0x6009881")]
		[Address(RVA = "0x18DC300", Offset = "0x18DB100", VA = "0x1818DC300")]
		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: 0x06009882 RID: 39042 RVA: 0x001F6DF0 File Offset: 0x001F4FF0
		[Token(Token = "0x6009882")]
		[Address(RVA = "0x18D9080", Offset = "0x18D7E80", VA = "0x1818D9080")]
		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: 0x06009883 RID: 39043 RVA: 0x001F6E6C File Offset: 0x001F506C
		[Token(Token = "0x6009883")]
		[Address(RVA = "0x18DC560", Offset = "0x18DB360", VA = "0x1818DC560")]
		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: 0x06009884 RID: 39044 RVA: 0x001F6ED8 File Offset: 0x001F50D8
		[Token(Token = "0x6009884")]
		[Address(RVA = "0x18DC840", Offset = "0x18DB640", VA = "0x1818DC840")]
		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: 0x06009885 RID: 39045 RVA: 0x001F6F7C File Offset: 0x001F517C
		[Token(Token = "0x6009885")]
		[Address(RVA = "0x18DC1F0", Offset = "0x18DAFF0", VA = "0x1818DC1F0")]
		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: 0x06009886 RID: 39046 RVA: 0x001F6FA4 File Offset: 0x001F51A4
		[Token(Token = "0x6009886")]
		[Address(RVA = "0x18DC240", Offset = "0x18DB040", VA = "0x1818DC240")]
		internal void put_byte(byte c)
		{
			int num = this.pending;
			byte[] array = this.pending_buf;
			int num2 = num + 1;
			this.pending = num2;
		}

		// Token: 0x06009887 RID: 39047 RVA: 0x001F6FD0 File Offset: 0x001F51D0
		[Token(Token = "0x6009887")]
		[Address(RVA = "0x18DC280", Offset = "0x18DB080", VA = "0x1818DC280")]
		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: 0x06009888 RID: 39048 RVA: 0x001F7018 File Offset: 0x001F5218
		[Token(Token = "0x6009888")]
		[Address(RVA = "0x18DC170", Offset = "0x18DAF70", VA = "0x1818DC170")]
		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: 0x06009889 RID: 39049 RVA: 0x001F7060 File Offset: 0x001F5260
		[Token(Token = "0x6009889")]
		[Address(RVA = "0x18DC7D0", Offset = "0x18DB5D0", VA = "0x1818DC7D0")]
		internal void send_code(int c, short[] tree)
		{
			int length = tree.Length;
			short num;
			short num2;
			this.send_bits((int)num, (int)num2);
		}

		// Token: 0x0600988A RID: 39050 RVA: 0x001F7084 File Offset: 0x001F5284
		[Token(Token = "0x600988A")]
		[Address(RVA = "0x18DC6E0", Offset = "0x18DB4E0", VA = "0x1818DC6E0")]
		internal void send_bits(int val, int length)
		{
			int num = this.bi_valid;
			uint num2;
			num2 -= (uint)length;
			this.bi_buf = (uint)val;
		}

		// Token: 0x0600988B RID: 39051 RVA: 0x001F7110 File Offset: 0x001F5310
		[Token(Token = "0x600988B")]
		[Address(RVA = "0x18D8410", Offset = "0x18D7210", VA = "0x1818D8410")]
		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: 0x0600988C RID: 39052 RVA: 0x001F71C0 File Offset: 0x001F53C0
		[Token(Token = "0x600988C")]
		[Address(RVA = "0x18D8B70", Offset = "0x18D7970", VA = "0x1818D8B70")]
		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: 0x0600988D RID: 39053 RVA: 0x001F72B4 File Offset: 0x001F54B4
		[Token(Token = "0x600988D")]
		[Address(RVA = "0x18D91E0", Offset = "0x18D7FE0", VA = "0x1818D91E0")]
		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: 0x0600988E RID: 39054 RVA: 0x001F73E8 File Offset: 0x001F55E8
		[Token(Token = "0x600988E")]
		[Address(RVA = "0x18DCA40", Offset = "0x18DB840", VA = "0x1818DCA40")]
		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: 0x0600988F RID: 39055 RVA: 0x001F7444 File Offset: 0x001F5644
		[Token(Token = "0x600988F")]
		[Address(RVA = "0x18D8EB0", Offset = "0x18D7CB0", VA = "0x1818D8EB0")]
		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: 0x06009890 RID: 39056 RVA: 0x001F74E0 File Offset: 0x001F56E0
		[Token(Token = "0x6009890")]
		[Address(RVA = "0x18D8FA0", Offset = "0x18D7DA0", VA = "0x1818D8FA0")]
		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: 0x06009891 RID: 39057 RVA: 0x001F7580 File Offset: 0x001F5780
		[Token(Token = "0x6009891")]
		[Address(RVA = "0x18D9690", Offset = "0x18D8490", VA = "0x1818D9690")]
		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: 0x06009892 RID: 39058 RVA: 0x001F75D0 File Offset: 0x001F57D0
		[Token(Token = "0x6009892")]
		[Address(RVA = "0x18DB530", Offset = "0x18DA330", VA = "0x1818DB530")]
		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: 0x06009893 RID: 39059 RVA: 0x001F761C File Offset: 0x001F581C
		[Token(Token = "0x6009893")]
		[Address(RVA = "0x18DB120", Offset = "0x18D9F20", VA = "0x1818DB120")]
		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: 0x06009894 RID: 39060 RVA: 0x001F7758 File Offset: 0x001F5958
		[Token(Token = "0x6009894")]
		[Address(RVA = "0x18D8AD0", Offset = "0x18D78D0", VA = "0x1818D8AD0")]
		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: 0x06009895 RID: 39061 RVA: 0x001F77B0 File Offset: 0x001F59B0
		[Token(Token = "0x6009895")]
		[Address(RVA = "0x18D85B0", Offset = "0x18D73B0", VA = "0x1818D85B0")]
		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: 0x06009896 RID: 39062 RVA: 0x001F7974 File Offset: 0x001F5B74
		[Token(Token = "0x6009896")]
		[Address(RVA = "0x18DB2D0", Offset = "0x18DA0D0", VA = "0x1818DB2D0")]
		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: 0x06009897 RID: 39063 RVA: 0x001F7AE4 File Offset: 0x001F5CE4
		[Token(Token = "0x6009897")]
		[Address(RVA = "0x18DA1B0", Offset = "0x18D8FB0", VA = "0x1818DA1B0")]
		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: 0x06009898 RID: 39064 RVA: 0x001F7DCC File Offset: 0x001F5FCC
		[Token(Token = "0x6009898")]
		[Address(RVA = "0x18DABA0", Offset = "0x18D99A0", VA = "0x1818DABA0")]
		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: 0x06009899 RID: 39065 RVA: 0x001F80A0 File Offset: 0x001F62A0
		[Token(Token = "0x6009899")]
		[Address(RVA = "0x18DB8F0", Offset = "0x18DA6F0", VA = "0x1818DB8F0")]
		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: 0x0600989A RID: 39066 RVA: 0x001F81CC File Offset: 0x001F63CC
		[Token(Token = "0x600989A")]
		[Address(RVA = "0x18D9AE0", Offset = "0x18D88E0", VA = "0x1818D9AE0")]
		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: 0x0600989B RID: 39067 RVA: 0x001F81E8 File Offset: 0x001F63E8
		[Token(Token = "0x600989B")]
		[Address(RVA = "0x18D9AB0", Offset = "0x18D88B0", VA = "0x1818D9AB0")]
		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: 0x0600989C RID: 39068 RVA: 0x001F8204 File Offset: 0x001F6404
		[Token(Token = "0x600989C")]
		[Address(RVA = "0x18D9760", Offset = "0x18D8560", VA = "0x1818D9760")]
		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: 0x0600989D RID: 39069 RVA: 0x001F8404 File Offset: 0x001F6604
		[Token(Token = "0x600989D")]
		[Address(RVA = "0x18D9DD0", Offset = "0x18D8BD0", VA = "0x1818D9DD0")]
		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: 0x0600989E RID: 39070 RVA: 0x001F8514 File Offset: 0x001F6714
		[Token(Token = "0x600989E")]
		[Address(RVA = "0x18D9720", Offset = "0x18D8520", VA = "0x1818D9720")]
		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: 0x0600989F RID: 39071 RVA: 0x001F8560 File Offset: 0x001F6760
		[Token(Token = "0x600989F")]
		[Address(RVA = "0x18D9B10", Offset = "0x18D8910", VA = "0x1818D9B10")]
		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: 0x060098A0 RID: 39072 RVA: 0x001F8658 File Offset: 0x001F6858
		[Token(Token = "0x60098A0")]
		[Address(RVA = "0x18D9F70", Offset = "0x18D8D70", VA = "0x1818D9F70")]
		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: 0x060098A1 RID: 39073 RVA: 0x001F8768 File Offset: 0x001F6968
		[Token(Token = "0x60098A1")]
		[Address(RVA = "0x18DA6B0", Offset = "0x18D94B0", VA = "0x1818DA6B0")]
		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: 0x040066EC RID: 26348
		[Token(Token = "0x40066EC")]
		private const int MAX_MEM_LEVEL = 9;

		// Token: 0x040066ED RID: 26349
		[Token(Token = "0x40066ED")]
		private const int Z_DEFAULT_COMPRESSION = -1;

		// Token: 0x040066EE RID: 26350
		[Token(Token = "0x40066EE")]
		private const int MAX_WBITS = 15;

		// Token: 0x040066EF RID: 26351
		[Token(Token = "0x40066EF")]
		private const int DEF_MEM_LEVEL = 8;

		// Token: 0x040066F0 RID: 26352
		[Token(Token = "0x40066F0")]
		private const int STORED = 0;

		// Token: 0x040066F1 RID: 26353
		[Token(Token = "0x40066F1")]
		private const int FAST = 1;

		// Token: 0x040066F2 RID: 26354
		[Token(Token = "0x40066F2")]
		private const int SLOW = 2;

		// Token: 0x040066F3 RID: 26355
		[Token(Token = "0x40066F3")]
		private static readonly Deflate.Config[] config_table;

		// Token: 0x040066F4 RID: 26356
		[Token(Token = "0x40066F4")]
		private static readonly string[] z_errmsg;

		// Token: 0x040066F5 RID: 26357
		[Token(Token = "0x40066F5")]
		private const int NeedMore = 0;

		// Token: 0x040066F6 RID: 26358
		[Token(Token = "0x40066F6")]
		private const int BlockDone = 1;

		// Token: 0x040066F7 RID: 26359
		[Token(Token = "0x40066F7")]
		private const int FinishStarted = 2;

		// Token: 0x040066F8 RID: 26360
		[Token(Token = "0x40066F8")]
		private const int FinishDone = 3;

		// Token: 0x040066F9 RID: 26361
		[Token(Token = "0x40066F9")]
		private const int PRESET_DICT = 32;

		// Token: 0x040066FA RID: 26362
		[Token(Token = "0x40066FA")]
		private const int Z_FILTERED = 1;

		// Token: 0x040066FB RID: 26363
		[Token(Token = "0x40066FB")]
		private const int Z_HUFFMAN_ONLY = 2;

		// Token: 0x040066FC RID: 26364
		[Token(Token = "0x40066FC")]
		private const int Z_DEFAULT_STRATEGY = 0;

		// Token: 0x040066FD RID: 26365
		[Token(Token = "0x40066FD")]
		private const int Z_NO_FLUSH = 0;

		// Token: 0x040066FE RID: 26366
		[Token(Token = "0x40066FE")]
		private const int Z_PARTIAL_FLUSH = 1;

		// Token: 0x040066FF RID: 26367
		[Token(Token = "0x40066FF")]
		private const int Z_SYNC_FLUSH = 2;

		// Token: 0x04006700 RID: 26368
		[Token(Token = "0x4006700")]
		private const int Z_FULL_FLUSH = 3;

		// Token: 0x04006701 RID: 26369
		[Token(Token = "0x4006701")]
		private const int Z_FINISH = 4;

		// Token: 0x04006702 RID: 26370
		[Token(Token = "0x4006702")]
		private const int Z_OK = 0;

		// Token: 0x04006703 RID: 26371
		[Token(Token = "0x4006703")]
		private const int Z_STREAM_END = 1;

		// Token: 0x04006704 RID: 26372
		[Token(Token = "0x4006704")]
		private const int Z_NEED_DICT = 2;

		// Token: 0x04006705 RID: 26373
		[Token(Token = "0x4006705")]
		private const int Z_ERRNO = -1;

		// Token: 0x04006706 RID: 26374
		[Token(Token = "0x4006706")]
		private const int Z_STREAM_ERROR = -2;

		// Token: 0x04006707 RID: 26375
		[Token(Token = "0x4006707")]
		private const int Z_DATA_ERROR = -3;

		// Token: 0x04006708 RID: 26376
		[Token(Token = "0x4006708")]
		private const int Z_MEM_ERROR = -4;

		// Token: 0x04006709 RID: 26377
		[Token(Token = "0x4006709")]
		private const int Z_BUF_ERROR = -5;

		// Token: 0x0400670A RID: 26378
		[Token(Token = "0x400670A")]
		private const int Z_VERSION_ERROR = -6;

		// Token: 0x0400670B RID: 26379
		[Token(Token = "0x400670B")]
		private const int INIT_STATE = 42;

		// Token: 0x0400670C RID: 26380
		[Token(Token = "0x400670C")]
		private const int BUSY_STATE = 113;

		// Token: 0x0400670D RID: 26381
		[Token(Token = "0x400670D")]
		private const int FINISH_STATE = 666;

		// Token: 0x0400670E RID: 26382
		[Token(Token = "0x400670E")]
		private const int Z_DEFLATED = 8;

		// Token: 0x0400670F RID: 26383
		[Token(Token = "0x400670F")]
		private const int STORED_BLOCK = 0;

		// Token: 0x04006710 RID: 26384
		[Token(Token = "0x4006710")]
		private const int STATIC_TREES = 1;

		// Token: 0x04006711 RID: 26385
		[Token(Token = "0x4006711")]
		private const int DYN_TREES = 2;

		// Token: 0x04006712 RID: 26386
		[Token(Token = "0x4006712")]
		private const int Z_BINARY = 0;

		// Token: 0x04006713 RID: 26387
		[Token(Token = "0x4006713")]
		private const int Z_ASCII = 1;

		// Token: 0x04006714 RID: 26388
		[Token(Token = "0x4006714")]
		private const int Z_UNKNOWN = 2;

		// Token: 0x04006715 RID: 26389
		[Token(Token = "0x4006715")]
		private const int Buf_size = 16;

		// Token: 0x04006716 RID: 26390
		[Token(Token = "0x4006716")]
		private const int REP_3_6 = 16;

		// Token: 0x04006717 RID: 26391
		[Token(Token = "0x4006717")]
		private const int REPZ_3_10 = 17;

		// Token: 0x04006718 RID: 26392
		[Token(Token = "0x4006718")]
		private const int REPZ_11_138 = 18;

		// Token: 0x04006719 RID: 26393
		[Token(Token = "0x4006719")]
		private const int MIN_MATCH = 3;

		// Token: 0x0400671A RID: 26394
		[Token(Token = "0x400671A")]
		private const int MAX_MATCH = 258;

		// Token: 0x0400671B RID: 26395
		[Token(Token = "0x400671B")]
		private const int MIN_LOOKAHEAD = 262;

		// Token: 0x0400671C RID: 26396
		[Token(Token = "0x400671C")]
		private const int MAX_BITS = 15;

		// Token: 0x0400671D RID: 26397
		[Token(Token = "0x400671D")]
		private const int D_CODES = 30;

		// Token: 0x0400671E RID: 26398
		[Token(Token = "0x400671E")]
		private const int BL_CODES = 19;

		// Token: 0x0400671F RID: 26399
		[Token(Token = "0x400671F")]
		private const int LENGTH_CODES = 29;

		// Token: 0x04006720 RID: 26400
		[Token(Token = "0x4006720")]
		private const int LITERALS = 256;

		// Token: 0x04006721 RID: 26401
		[Token(Token = "0x4006721")]
		private const int L_CODES = 286;

		// Token: 0x04006722 RID: 26402
		[Token(Token = "0x4006722")]
		private const int HEAP_SIZE = 573;

		// Token: 0x04006723 RID: 26403
		[Token(Token = "0x4006723")]
		private const int END_BLOCK = 256;

		// Token: 0x04006724 RID: 26404
		[FieldOffset(Offset = "0x10")]
		[Token(Token = "0x4006724")]
		internal ZStream strm;

		// Token: 0x04006725 RID: 26405
		[FieldOffset(Offset = "0x18")]
		[Token(Token = "0x4006725")]
		internal int status;

		// Token: 0x04006726 RID: 26406
		[FieldOffset(Offset = "0x20")]
		[Token(Token = "0x4006726")]
		internal byte[] pending_buf;

		// Token: 0x04006727 RID: 26407
		[FieldOffset(Offset = "0x28")]
		[Token(Token = "0x4006727")]
		internal int pending_buf_size;

		// Token: 0x04006728 RID: 26408
		[FieldOffset(Offset = "0x2C")]
		[Token(Token = "0x4006728")]
		internal int pending_out;

		// Token: 0x04006729 RID: 26409
		[FieldOffset(Offset = "0x30")]
		[Token(Token = "0x4006729")]
		internal int pending;

		// Token: 0x0400672A RID: 26410
		[FieldOffset(Offset = "0x34")]
		[Token(Token = "0x400672A")]
		internal int noheader;

		// Token: 0x0400672B RID: 26411
		[FieldOffset(Offset = "0x38")]
		[Token(Token = "0x400672B")]
		internal byte data_type;

		// Token: 0x0400672C RID: 26412
		[FieldOffset(Offset = "0x39")]
		[Token(Token = "0x400672C")]
		internal byte method;

		// Token: 0x0400672D RID: 26413
		[FieldOffset(Offset = "0x3C")]
		[Token(Token = "0x400672D")]
		internal int last_flush;

		// Token: 0x0400672E RID: 26414
		[FieldOffset(Offset = "0x40")]
		[Token(Token = "0x400672E")]
		internal int w_size;

		// Token: 0x0400672F RID: 26415
		[FieldOffset(Offset = "0x44")]
		[Token(Token = "0x400672F")]
		internal int w_bits;

		// Token: 0x04006730 RID: 26416
		[FieldOffset(Offset = "0x48")]
		[Token(Token = "0x4006730")]
		internal int w_mask;

		// Token: 0x04006731 RID: 26417
		[FieldOffset(Offset = "0x50")]
		[Token(Token = "0x4006731")]
		internal byte[] window;

		// Token: 0x04006732 RID: 26418
		[FieldOffset(Offset = "0x58")]
		[Token(Token = "0x4006732")]
		internal int window_size;

		// Token: 0x04006733 RID: 26419
		[FieldOffset(Offset = "0x60")]
		[Token(Token = "0x4006733")]
		internal short[] prev;

		// Token: 0x04006734 RID: 26420
		[FieldOffset(Offset = "0x68")]
		[Token(Token = "0x4006734")]
		internal short[] head;

		// Token: 0x04006735 RID: 26421
		[FieldOffset(Offset = "0x70")]
		[Token(Token = "0x4006735")]
		internal int ins_h;

		// Token: 0x04006736 RID: 26422
		[FieldOffset(Offset = "0x74")]
		[Token(Token = "0x4006736")]
		internal int hash_size;

		// Token: 0x04006737 RID: 26423
		[FieldOffset(Offset = "0x78")]
		[Token(Token = "0x4006737")]
		internal int hash_bits;

		// Token: 0x04006738 RID: 26424
		[FieldOffset(Offset = "0x7C")]
		[Token(Token = "0x4006738")]
		internal int hash_mask;

		// Token: 0x04006739 RID: 26425
		[FieldOffset(Offset = "0x80")]
		[Token(Token = "0x4006739")]
		internal int hash_shift;

		// Token: 0x0400673A RID: 26426
		[FieldOffset(Offset = "0x84")]
		[Token(Token = "0x400673A")]
		internal int block_start;

		// Token: 0x0400673B RID: 26427
		[FieldOffset(Offset = "0x88")]
		[Token(Token = "0x400673B")]
		internal int match_length;

		// Token: 0x0400673C RID: 26428
		[FieldOffset(Offset = "0x8C")]
		[Token(Token = "0x400673C")]
		internal int prev_match;

		// Token: 0x0400673D RID: 26429
		[FieldOffset(Offset = "0x90")]
		[Token(Token = "0x400673D")]
		internal int match_available;

		// Token: 0x0400673E RID: 26430
		[FieldOffset(Offset = "0x94")]
		[Token(Token = "0x400673E")]
		internal int strstart;

		// Token: 0x0400673F RID: 26431
		[FieldOffset(Offset = "0x98")]
		[Token(Token = "0x400673F")]
		internal int match_start;

		// Token: 0x04006740 RID: 26432
		[FieldOffset(Offset = "0x9C")]
		[Token(Token = "0x4006740")]
		internal int lookahead;

		// Token: 0x04006741 RID: 26433
		[FieldOffset(Offset = "0xA0")]
		[Token(Token = "0x4006741")]
		internal int prev_length;

		// Token: 0x04006742 RID: 26434
		[FieldOffset(Offset = "0xA4")]
		[Token(Token = "0x4006742")]
		internal int max_chain_length;

		// Token: 0x04006743 RID: 26435
		[FieldOffset(Offset = "0xA8")]
		[Token(Token = "0x4006743")]
		internal int max_lazy_match;

		// Token: 0x04006744 RID: 26436
		[FieldOffset(Offset = "0xAC")]
		[Token(Token = "0x4006744")]
		internal int level;

		// Token: 0x04006745 RID: 26437
		[FieldOffset(Offset = "0xB0")]
		[Token(Token = "0x4006745")]
		internal int strategy;

		// Token: 0x04006746 RID: 26438
		[FieldOffset(Offset = "0xB4")]
		[Token(Token = "0x4006746")]
		internal int good_match;

		// Token: 0x04006747 RID: 26439
		[FieldOffset(Offset = "0xB8")]
		[Token(Token = "0x4006747")]
		internal int nice_match;

		// Token: 0x04006748 RID: 26440
		[FieldOffset(Offset = "0xC0")]
		[Token(Token = "0x4006748")]
		internal short[] dyn_ltree;

		// Token: 0x04006749 RID: 26441
		[FieldOffset(Offset = "0xC8")]
		[Token(Token = "0x4006749")]
		internal short[] dyn_dtree;

		// Token: 0x0400674A RID: 26442
		[FieldOffset(Offset = "0xD0")]
		[Token(Token = "0x400674A")]
		internal short[] bl_tree;

		// Token: 0x0400674B RID: 26443
		[FieldOffset(Offset = "0xD8")]
		[Token(Token = "0x400674B")]
		internal ZTree l_desc;

		// Token: 0x0400674C RID: 26444
		[FieldOffset(Offset = "0xE0")]
		[Token(Token = "0x400674C")]
		internal ZTree d_desc;

		// Token: 0x0400674D RID: 26445
		[FieldOffset(Offset = "0xE8")]
		[Token(Token = "0x400674D")]
		internal ZTree bl_desc;

		// Token: 0x0400674E RID: 26446
		[FieldOffset(Offset = "0xF0")]
		[Token(Token = "0x400674E")]
		internal short[] bl_count;

		// Token: 0x0400674F RID: 26447
		[FieldOffset(Offset = "0xF8")]
		[Token(Token = "0x400674F")]
		internal int[] heap;

		// Token: 0x04006750 RID: 26448
		[FieldOffset(Offset = "0x100")]
		[Token(Token = "0x4006750")]
		internal int heap_len;

		// Token: 0x04006751 RID: 26449
		[FieldOffset(Offset = "0x104")]
		[Token(Token = "0x4006751")]
		internal int heap_max;

		// Token: 0x04006752 RID: 26450
		[FieldOffset(Offset = "0x108")]
		[Token(Token = "0x4006752")]
		internal byte[] depth;

		// Token: 0x04006753 RID: 26451
		[FieldOffset(Offset = "0x110")]
		[Token(Token = "0x4006753")]
		internal int l_buf;

		// Token: 0x04006754 RID: 26452
		[FieldOffset(Offset = "0x114")]
		[Token(Token = "0x4006754")]
		internal int lit_bufsize;

		// Token: 0x04006755 RID: 26453
		[FieldOffset(Offset = "0x118")]
		[Token(Token = "0x4006755")]
		internal int last_lit;

		// Token: 0x04006756 RID: 26454
		[FieldOffset(Offset = "0x11C")]
		[Token(Token = "0x4006756")]
		internal int d_buf;

		// Token: 0x04006757 RID: 26455
		[FieldOffset(Offset = "0x120")]
		[Token(Token = "0x4006757")]
		internal int opt_len;

		// Token: 0x04006758 RID: 26456
		[FieldOffset(Offset = "0x124")]
		[Token(Token = "0x4006758")]
		internal int static_len;

		// Token: 0x04006759 RID: 26457
		[FieldOffset(Offset = "0x128")]
		[Token(Token = "0x4006759")]
		internal int matches;

		// Token: 0x0400675A RID: 26458
		[FieldOffset(Offset = "0x12C")]
		[Token(Token = "0x400675A")]
		internal int last_eob_len;

		// Token: 0x0400675B RID: 26459
		[FieldOffset(Offset = "0x130")]
		[Token(Token = "0x400675B")]
		internal uint bi_buf;

		// Token: 0x0400675C RID: 26460
		[FieldOffset(Offset = "0x134")]
		[Token(Token = "0x400675C")]
		internal int bi_valid;

		// Token: 0x0200192B RID: 6443
		[Token(Token = "0x200192B")]
		internal class Config
		{
			// Token: 0x060098A2 RID: 39074 RVA: 0x001F8A00 File Offset: 0x001F6C00
			[Token(Token = "0x60098A2")]
			[Address(RVA = "0x18D7470", Offset = "0x18D6270", VA = "0x1818D7470")]
			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: 0x0400675D RID: 26461
			[FieldOffset(Offset = "0x10")]
			[Token(Token = "0x400675D")]
			internal int good_length;

			// Token: 0x0400675E RID: 26462
			[FieldOffset(Offset = "0x14")]
			[Token(Token = "0x400675E")]
			internal int max_lazy;

			// Token: 0x0400675F RID: 26463
			[FieldOffset(Offset = "0x18")]
			[Token(Token = "0x400675F")]
			internal int nice_length;

			// Token: 0x04006760 RID: 26464
			[FieldOffset(Offset = "0x1C")]
			[Token(Token = "0x4006760")]
			internal int max_chain;

			// Token: 0x04006761 RID: 26465
			[FieldOffset(Offset = "0x20")]
			[Token(Token = "0x4006761")]
			internal int func;
		}
	}
}