using System;
using System.IO;

namespace ICSharpCode.SharpZipLib.Zip
{
	// Token: 0x02000056 RID: 86
	public class ZipEntry : ICloneable
	{
		// Token: 0x0600032E RID: 814 RVA: 0x000115C0 File Offset: 0x000105C0
		public ZipEntry(string name)
			: this(name, 0, 51, CompressionMethod.Deflated)
		{
		}

		// Token: 0x0600032F RID: 815 RVA: 0x000115CD File Offset: 0x000105CD
		internal ZipEntry(string name, int versionRequiredToExtract)
			: this(name, versionRequiredToExtract, 51, CompressionMethod.Deflated)
		{
		}

		// Token: 0x06000330 RID: 816 RVA: 0x000115DC File Offset: 0x000105DC
		internal ZipEntry(string name, int versionRequiredToExtract, int madeByInfo, CompressionMethod method)
		{
			this.externalFileAttributes = -1;
			this.method = CompressionMethod.Deflated;
			this.zipFileIndex = -1L;
			base..ctor();
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (name.Length > 65535)
			{
				throw new ArgumentException("Name is too long", "name");
			}
			if (versionRequiredToExtract != 0 && versionRequiredToExtract < 10)
			{
				throw new ArgumentOutOfRangeException("versionRequiredToExtract");
			}
			this.DateTime = DateTime.Now;
			this.name = name;
			this.versionMadeBy = (ushort)madeByInfo;
			this.versionToExtract = (ushort)versionRequiredToExtract;
			this.method = method;
		}

		// Token: 0x06000331 RID: 817 RVA: 0x00011670 File Offset: 0x00010670
		[Obsolete("Use Clone instead")]
		public ZipEntry(ZipEntry entry)
		{
			this.externalFileAttributes = -1;
			this.method = CompressionMethod.Deflated;
			this.zipFileIndex = -1L;
			base..ctor();
			if (entry == null)
			{
				throw new ArgumentNullException("entry");
			}
			this.known = entry.known;
			this.name = entry.name;
			this.size = entry.size;
			this.compressedSize = entry.compressedSize;
			this.crc = entry.crc;
			this.dosTime = entry.dosTime;
			this.method = entry.method;
			this.comment = entry.comment;
			this.versionToExtract = entry.versionToExtract;
			this.versionMadeBy = entry.versionMadeBy;
			this.externalFileAttributes = entry.externalFileAttributes;
			this.flags = entry.flags;
			this.zipFileIndex = entry.zipFileIndex;
			this.offset = entry.offset;
			this.forceZip64_ = entry.forceZip64_;
			if (entry.extra != null)
			{
				this.extra = new byte[entry.extra.Length];
				Array.Copy(entry.extra, 0, this.extra, 0, entry.extra.Length);
			}
		}

		// Token: 0x170000AA RID: 170
		// (get) Token: 0x06000332 RID: 818 RVA: 0x00011791 File Offset: 0x00010791
		public bool HasCrc
		{
			get
			{
				return (byte)(this.known & ZipEntry.Known.Crc) != 0;
			}
		}

		// Token: 0x170000AB RID: 171
		// (get) Token: 0x06000333 RID: 819 RVA: 0x000117A2 File Offset: 0x000107A2
		// (set) Token: 0x06000334 RID: 820 RVA: 0x000117B2 File Offset: 0x000107B2
		public bool IsCrypted
		{
			get
			{
				return (this.flags & 1) != 0;
			}
			set
			{
				if (value)
				{
					this.flags |= 1;
					return;
				}
				this.flags &= -2;
			}
		}

		// Token: 0x170000AC RID: 172
		// (get) Token: 0x06000335 RID: 821 RVA: 0x000117D5 File Offset: 0x000107D5
		// (set) Token: 0x06000336 RID: 822 RVA: 0x000117E9 File Offset: 0x000107E9
		public bool IsUnicodeText
		{
			get
			{
				return (this.flags & 2048) != 0;
			}
			set
			{
				if (value)
				{
					this.flags |= 2048;
					return;
				}
				this.flags &= -2049;
			}
		}

		// Token: 0x170000AD RID: 173
		// (get) Token: 0x06000337 RID: 823 RVA: 0x00011813 File Offset: 0x00010813
		// (set) Token: 0x06000338 RID: 824 RVA: 0x0001181B File Offset: 0x0001081B
		internal byte CryptoCheckValue
		{
			get
			{
				return this.cryptoCheckValue_;
			}
			set
			{
				this.cryptoCheckValue_ = value;
			}
		}

		// Token: 0x170000AE RID: 174
		// (get) Token: 0x06000339 RID: 825 RVA: 0x00011824 File Offset: 0x00010824
		// (set) Token: 0x0600033A RID: 826 RVA: 0x0001182C File Offset: 0x0001082C
		public int Flags
		{
			get
			{
				return this.flags;
			}
			set
			{
				this.flags = value;
			}
		}

		// Token: 0x170000AF RID: 175
		// (get) Token: 0x0600033B RID: 827 RVA: 0x00011835 File Offset: 0x00010835
		// (set) Token: 0x0600033C RID: 828 RVA: 0x0001183D File Offset: 0x0001083D
		public long ZipFileIndex
		{
			get
			{
				return this.zipFileIndex;
			}
			set
			{
				this.zipFileIndex = value;
			}
		}

		// Token: 0x170000B0 RID: 176
		// (get) Token: 0x0600033D RID: 829 RVA: 0x00011846 File Offset: 0x00010846
		// (set) Token: 0x0600033E RID: 830 RVA: 0x0001184E File Offset: 0x0001084E
		public long Offset
		{
			get
			{
				return this.offset;
			}
			set
			{
				this.offset = value;
			}
		}

		// Token: 0x170000B1 RID: 177
		// (get) Token: 0x0600033F RID: 831 RVA: 0x00011857 File Offset: 0x00010857
		// (set) Token: 0x06000340 RID: 832 RVA: 0x0001186D File Offset: 0x0001086D
		public int ExternalFileAttributes
		{
			get
			{
				if ((byte)(this.known & ZipEntry.Known.ExternalAttributes) == 0)
				{
					return -1;
				}
				return this.externalFileAttributes;
			}
			set
			{
				this.externalFileAttributes = value;
				this.known |= ZipEntry.Known.ExternalAttributes;
			}
		}

		// Token: 0x170000B2 RID: 178
		// (get) Token: 0x06000341 RID: 833 RVA: 0x00011886 File Offset: 0x00010886
		public int VersionMadeBy
		{
			get
			{
				return (int)(this.versionMadeBy & 255);
			}
		}

		// Token: 0x170000B3 RID: 179
		// (get) Token: 0x06000342 RID: 834 RVA: 0x00011894 File Offset: 0x00010894
		public bool IsDOSEntry
		{
			get
			{
				return this.HostSystem == 0 || this.HostSystem == 10;
			}
		}

		// Token: 0x06000343 RID: 835 RVA: 0x000118AC File Offset: 0x000108AC
		private bool HasDosAttributes(int attributes)
		{
			bool flag = false;
			if ((byte)(this.known & ZipEntry.Known.ExternalAttributes) != 0 && (this.HostSystem == 0 || this.HostSystem == 10) && (this.ExternalFileAttributes & attributes) == attributes)
			{
				flag = true;
			}
			return flag;
		}

		// Token: 0x170000B4 RID: 180
		// (get) Token: 0x06000344 RID: 836 RVA: 0x000118E7 File Offset: 0x000108E7
		// (set) Token: 0x06000345 RID: 837 RVA: 0x000118F7 File Offset: 0x000108F7
		public int HostSystem
		{
			get
			{
				return (this.versionMadeBy >> 8) & 255;
			}
			set
			{
				this.versionMadeBy &= 255;
				this.versionMadeBy |= (ushort)((value & 255) << 8);
			}
		}

		// Token: 0x170000B5 RID: 181
		// (get) Token: 0x06000346 RID: 838 RVA: 0x00011924 File Offset: 0x00010924
		public int Version
		{
			get
			{
				if (this.versionToExtract != 0)
				{
					return (int)this.versionToExtract;
				}
				int num = 10;
				if (this.AESKeySize > 0)
				{
					num = 51;
				}
				else if (this.CentralHeaderRequiresZip64)
				{
					num = 45;
				}
				else if (CompressionMethod.Deflated == this.method)
				{
					num = 20;
				}
				else if (this.IsDirectory)
				{
					num = 20;
				}
				else if (this.IsCrypted)
				{
					num = 20;
				}
				else if (this.HasDosAttributes(8))
				{
					num = 11;
				}
				return num;
			}
		}

		// Token: 0x170000B6 RID: 182
		// (get) Token: 0x06000347 RID: 839 RVA: 0x00011994 File Offset: 0x00010994
		public bool CanDecompress
		{
			get
			{
				return this.Version <= 51 && (this.Version == 10 || this.Version == 11 || this.Version == 20 || this.Version == 45 || this.Version == 51) && this.IsCompressionMethodSupported();
			}
		}

		// Token: 0x06000348 RID: 840 RVA: 0x000119E5 File Offset: 0x000109E5
		public void ForceZip64()
		{
			this.forceZip64_ = true;
		}

		// Token: 0x06000349 RID: 841 RVA: 0x000119EE File Offset: 0x000109EE
		public bool IsZip64Forced()
		{
			return this.forceZip64_;
		}

		// Token: 0x170000B7 RID: 183
		// (get) Token: 0x0600034A RID: 842 RVA: 0x000119F8 File Offset: 0x000109F8
		public bool LocalHeaderRequiresZip64
		{
			get
			{
				bool flag = this.forceZip64_;
				if (!flag)
				{
					ulong num = this.compressedSize;
					if (this.versionToExtract == 0 && this.IsCrypted)
					{
						num += 12UL;
					}
					flag = (this.size >= (ulong)(-1) || num >= (ulong)(-1)) && (this.versionToExtract == 0 || this.versionToExtract >= 45);
				}
				return flag;
			}
		}

		// Token: 0x170000B8 RID: 184
		// (get) Token: 0x0600034B RID: 843 RVA: 0x00011A58 File Offset: 0x00010A58
		public bool CentralHeaderRequiresZip64
		{
			get
			{
				return this.LocalHeaderRequiresZip64 || this.offset >= (long)((ulong)(-1));
			}
		}

		// Token: 0x170000B9 RID: 185
		// (get) Token: 0x0600034C RID: 844 RVA: 0x00011A71 File Offset: 0x00010A71
		// (set) Token: 0x0600034D RID: 845 RVA: 0x00011A88 File Offset: 0x00010A88
		public long DosTime
		{
			get
			{
				if ((byte)(this.known & ZipEntry.Known.Time) == 0)
				{
					return 0L;
				}
				return (long)((ulong)this.dosTime);
			}
			set
			{
				this.dosTime = (uint)value;
				this.known |= ZipEntry.Known.Time;
			}
		}

		// Token: 0x170000BA RID: 186
		// (get) Token: 0x0600034E RID: 846 RVA: 0x00011AA4 File Offset: 0x00010AA4
		// (set) Token: 0x0600034F RID: 847 RVA: 0x00011B48 File Offset: 0x00010B48
		public DateTime DateTime
		{
			get
			{
				uint num = Math.Min(59U, 2U * (this.dosTime & 31U));
				uint num2 = Math.Min(59U, (this.dosTime >> 5) & 63U);
				uint num3 = Math.Min(23U, (this.dosTime >> 11) & 31U);
				uint num4 = Math.Max(1U, Math.Min(12U, (this.dosTime >> 21) & 15U));
				uint num5 = ((this.dosTime >> 25) & 127U) + 1980U;
				int num6 = Math.Max(1, Math.Min(DateTime.DaysInMonth((int)num5, (int)num4), (int)((this.dosTime >> 16) & 31U)));
				return new DateTime((int)num5, (int)num4, num6, (int)num3, (int)num2, (int)num);
			}
			set
			{
				uint num = (uint)value.Year;
				uint num2 = (uint)value.Month;
				uint num3 = (uint)value.Day;
				uint num4 = (uint)value.Hour;
				uint num5 = (uint)value.Minute;
				uint num6 = (uint)value.Second;
				if (num < 1980U)
				{
					num = 1980U;
					num2 = 1U;
					num3 = 1U;
					num4 = 0U;
					num5 = 0U;
					num6 = 0U;
				}
				else if (num > 2107U)
				{
					num = 2107U;
					num2 = 12U;
					num3 = 31U;
					num4 = 23U;
					num5 = 59U;
					num6 = 59U;
				}
				this.DosTime = (long)((ulong)((((num - 1980U) & 127U) << 25) | (num2 << 21) | (num3 << 16) | (num4 << 11) | (num5 << 5) | (num6 >> 1)));
			}
		}

		// Token: 0x170000BB RID: 187
		// (get) Token: 0x06000350 RID: 848 RVA: 0x00011BEF File Offset: 0x00010BEF
		public string Name
		{
			get
			{
				return this.name;
			}
		}

		// Token: 0x170000BC RID: 188
		// (get) Token: 0x06000351 RID: 849 RVA: 0x00011BF7 File Offset: 0x00010BF7
		// (set) Token: 0x06000352 RID: 850 RVA: 0x00011C0D File Offset: 0x00010C0D
		public long Size
		{
			get
			{
				if ((byte)(this.known & ZipEntry.Known.Size) == 0)
				{
					return -1L;
				}
				return (long)this.size;
			}
			set
			{
				this.size = (ulong)value;
				this.known |= ZipEntry.Known.Size;
			}
		}

		// Token: 0x170000BD RID: 189
		// (get) Token: 0x06000353 RID: 851 RVA: 0x00011C25 File Offset: 0x00010C25
		// (set) Token: 0x06000354 RID: 852 RVA: 0x00011C3B File Offset: 0x00010C3B
		public long CompressedSize
		{
			get
			{
				if ((byte)(this.known & ZipEntry.Known.CompressedSize) == 0)
				{
					return -1L;
				}
				return (long)this.compressedSize;
			}
			set
			{
				this.compressedSize = (ulong)value;
				this.known |= ZipEntry.Known.CompressedSize;
			}
		}

		// Token: 0x170000BE RID: 190
		// (get) Token: 0x06000355 RID: 853 RVA: 0x00011C53 File Offset: 0x00010C53
		// (set) Token: 0x06000356 RID: 854 RVA: 0x00011C6D File Offset: 0x00010C6D
		public long Crc
		{
			get
			{
				if ((byte)(this.known & ZipEntry.Known.Crc) == 0)
				{
					return -1L;
				}
				return (long)((ulong)this.crc & (ulong)(-1));
			}
			set
			{
				if (((ulong)this.crc & 18446744069414584320UL) != 0UL)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				this.crc = (uint)value;
				this.known |= ZipEntry.Known.Crc;
			}
		}

		// Token: 0x170000BF RID: 191
		// (get) Token: 0x06000357 RID: 855 RVA: 0x00011CA6 File Offset: 0x00010CA6
		// (set) Token: 0x06000358 RID: 856 RVA: 0x00011CAE File Offset: 0x00010CAE
		public CompressionMethod CompressionMethod
		{
			get
			{
				return this.method;
			}
			set
			{
				if (!ZipEntry.IsCompressionMethodSupported(value))
				{
					throw new NotSupportedException("Compression method not supported");
				}
				this.method = value;
			}
		}

		// Token: 0x170000C0 RID: 192
		// (get) Token: 0x06000359 RID: 857 RVA: 0x00011CCA File Offset: 0x00010CCA
		internal CompressionMethod CompressionMethodForHeader
		{
			get
			{
				if (this.AESKeySize <= 0)
				{
					return this.method;
				}
				return CompressionMethod.WinZipAES;
			}
		}

		// Token: 0x170000C1 RID: 193
		// (get) Token: 0x0600035A RID: 858 RVA: 0x00011CDE File Offset: 0x00010CDE
		// (set) Token: 0x0600035B RID: 859 RVA: 0x00011CE8 File Offset: 0x00010CE8
		public byte[] ExtraData
		{
			get
			{
				return this.extra;
			}
			set
			{
				if (value == null)
				{
					this.extra = null;
					return;
				}
				if (value.Length > 65535)
				{
					throw new ArgumentOutOfRangeException("value");
				}
				this.extra = new byte[value.Length];
				Array.Copy(value, 0, this.extra, 0, value.Length);
			}
		}

		// Token: 0x170000C2 RID: 194
		// (get) Token: 0x0600035C RID: 860 RVA: 0x00011D34 File Offset: 0x00010D34
		// (set) Token: 0x0600035D RID: 861 RVA: 0x00011D90 File Offset: 0x00010D90
		public int AESKeySize
		{
			get
			{
				switch (this._aesEncryptionStrength)
				{
				case 0:
					return 0;
				case 1:
					return 128;
				case 2:
					return 192;
				case 3:
					return 256;
				default:
					throw new ZipException("Invalid AESEncryptionStrength " + this._aesEncryptionStrength);
				}
			}
			set
			{
				if (value == 0)
				{
					this._aesEncryptionStrength = 0;
					return;
				}
				if (value == 128)
				{
					this._aesEncryptionStrength = 1;
					return;
				}
				if (value != 256)
				{
					throw new ZipException("AESKeySize must be 0, 128 or 256: " + value);
				}
				this._aesEncryptionStrength = 3;
			}
		}

		// Token: 0x170000C3 RID: 195
		// (get) Token: 0x0600035E RID: 862 RVA: 0x00011DE2 File Offset: 0x00010DE2
		internal byte AESEncryptionStrength
		{
			get
			{
				return (byte)this._aesEncryptionStrength;
			}
		}

		// Token: 0x170000C4 RID: 196
		// (get) Token: 0x0600035F RID: 863 RVA: 0x00011DEB File Offset: 0x00010DEB
		internal int AESSaltLen
		{
			get
			{
				return this.AESKeySize / 16;
			}
		}

		// Token: 0x170000C5 RID: 197
		// (get) Token: 0x06000360 RID: 864 RVA: 0x00011DF6 File Offset: 0x00010DF6
		internal int AESOverheadSize
		{
			get
			{
				return 12 + this.AESSaltLen;
			}
		}

		// Token: 0x06000361 RID: 865 RVA: 0x00011E04 File Offset: 0x00010E04
		internal void ProcessExtraData(bool localHeader)
		{
			ZipExtraData zipExtraData = new ZipExtraData(this.extra);
			if (zipExtraData.Find(1))
			{
				this.forceZip64_ = true;
				if (zipExtraData.ValueLength < 4)
				{
					throw new ZipException("Extra data extended Zip64 information length is invalid");
				}
				if (localHeader || this.size == (ulong)(-1))
				{
					this.size = (ulong)zipExtraData.ReadLong();
				}
				if (localHeader || this.compressedSize == (ulong)(-1))
				{
					this.compressedSize = (ulong)zipExtraData.ReadLong();
				}
				if (!localHeader && this.offset == (long)((ulong)(-1)))
				{
					this.offset = zipExtraData.ReadLong();
				}
			}
			else if ((this.versionToExtract & 255) >= 45 && (this.size == (ulong)(-1) || this.compressedSize == (ulong)(-1)))
			{
				throw new ZipException("Zip64 Extended information required but is missing.");
			}
			if (zipExtraData.Find(10))
			{
				if (zipExtraData.ValueLength < 4)
				{
					throw new ZipException("NTFS Extra data invalid");
				}
				zipExtraData.ReadInt();
				while (zipExtraData.UnreadCount >= 4)
				{
					int num = zipExtraData.ReadShort();
					int num2 = zipExtraData.ReadShort();
					if (num == 1)
					{
						if (num2 >= 24)
						{
							long num3 = zipExtraData.ReadLong();
							zipExtraData.ReadLong();
							zipExtraData.ReadLong();
							this.DateTime = DateTime.FromFileTime(num3);
							break;
						}
						break;
					}
					else
					{
						zipExtraData.Skip(num2);
					}
				}
			}
			else if (zipExtraData.Find(21589))
			{
				int valueLength = zipExtraData.ValueLength;
				int num4 = zipExtraData.ReadByte();
				if ((num4 & 1) != 0 && valueLength >= 5)
				{
					int num5 = zipExtraData.ReadInt();
					this.DateTime = (new DateTime(1970, 1, 1, 0, 0, 0).ToUniversalTime() + new TimeSpan(0, 0, 0, num5, 0)).ToLocalTime();
				}
			}
			if (this.method == CompressionMethod.WinZipAES)
			{
				this.ProcessAESExtraData(zipExtraData);
			}
		}

		// Token: 0x06000362 RID: 866 RVA: 0x00011FAC File Offset: 0x00010FAC
		private void ProcessAESExtraData(ZipExtraData extraData)
		{
			if (!extraData.Find(39169))
			{
				throw new ZipException("AES Extra Data missing");
			}
			this.versionToExtract = 51;
			this.Flags |= 64;
			int valueLength = extraData.ValueLength;
			if (valueLength < 7)
			{
				throw new ZipException("AES Extra Data Length " + valueLength + " invalid.");
			}
			int num = extraData.ReadShort();
			extraData.ReadShort();
			int num2 = extraData.ReadByte();
			int num3 = extraData.ReadShort();
			this._aesVer = num;
			this._aesEncryptionStrength = num2;
			this.method = (CompressionMethod)num3;
		}

		// Token: 0x170000C6 RID: 198
		// (get) Token: 0x06000363 RID: 867 RVA: 0x0001203F File Offset: 0x0001103F
		// (set) Token: 0x06000364 RID: 868 RVA: 0x00012047 File Offset: 0x00011047
		public string Comment
		{
			get
			{
				return this.comment;
			}
			set
			{
				if (value != null && value.Length > 65535)
				{
					throw new ArgumentOutOfRangeException("value", "cannot exceed 65535");
				}
				this.comment = value;
			}
		}

		// Token: 0x170000C7 RID: 199
		// (get) Token: 0x06000365 RID: 869 RVA: 0x00012070 File Offset: 0x00011070
		public bool IsDirectory
		{
			get
			{
				int length = this.name.Length;
				return (length > 0 && (this.name[length - 1] == '/' || this.name[length - 1] == '\\')) || this.HasDosAttributes(16);
			}
		}

		// Token: 0x170000C8 RID: 200
		// (get) Token: 0x06000366 RID: 870 RVA: 0x000120BE File Offset: 0x000110BE
		public bool IsFile
		{
			get
			{
				return !this.IsDirectory && !this.HasDosAttributes(8);
			}
		}

		// Token: 0x06000367 RID: 871 RVA: 0x000120D4 File Offset: 0x000110D4
		public bool IsCompressionMethodSupported()
		{
			return ZipEntry.IsCompressionMethodSupported(this.CompressionMethod);
		}

		// Token: 0x06000368 RID: 872 RVA: 0x000120E4 File Offset: 0x000110E4
		public object Clone()
		{
			ZipEntry zipEntry = (ZipEntry)base.MemberwiseClone();
			if (this.extra != null)
			{
				zipEntry.extra = new byte[this.extra.Length];
				Array.Copy(this.extra, 0, zipEntry.extra, 0, this.extra.Length);
			}
			return zipEntry;
		}

		// Token: 0x06000369 RID: 873 RVA: 0x00012134 File Offset: 0x00011134
		public override string ToString()
		{
			return this.name;
		}

		// Token: 0x0600036A RID: 874 RVA: 0x0001213C File Offset: 0x0001113C
		public static bool IsCompressionMethodSupported(CompressionMethod method)
		{
			return method == CompressionMethod.Deflated || method == CompressionMethod.Stored;
		}

		// Token: 0x0600036B RID: 875 RVA: 0x00012148 File Offset: 0x00011148
		public static string CleanName(string name)
		{
			if (name == null)
			{
				return string.Empty;
			}
			if (Path.IsPathRooted(name))
			{
				name = name.Substring(Path.GetPathRoot(name).Length);
			}
			name = name.Replace("\\", "/");
			while (name.Length > 0 && name[0] == '/')
			{
				name = name.Remove(0, 1);
			}
			return name;
		}

		// Token: 0x04000286 RID: 646
		private ZipEntry.Known known;

		// Token: 0x04000287 RID: 647
		private int externalFileAttributes;

		// Token: 0x04000288 RID: 648
		private ushort versionMadeBy;

		// Token: 0x04000289 RID: 649
		private string name;

		// Token: 0x0400028A RID: 650
		private ulong size;

		// Token: 0x0400028B RID: 651
		private ulong compressedSize;

		// Token: 0x0400028C RID: 652
		private ushort versionToExtract;

		// Token: 0x0400028D RID: 653
		private uint crc;

		// Token: 0x0400028E RID: 654
		private uint dosTime;

		// Token: 0x0400028F RID: 655
		private CompressionMethod method;

		// Token: 0x04000290 RID: 656
		private byte[] extra;

		// Token: 0x04000291 RID: 657
		private string comment;

		// Token: 0x04000292 RID: 658
		private int flags;

		// Token: 0x04000293 RID: 659
		private long zipFileIndex;

		// Token: 0x04000294 RID: 660
		private long offset;

		// Token: 0x04000295 RID: 661
		private bool forceZip64_;

		// Token: 0x04000296 RID: 662
		private byte cryptoCheckValue_;

		// Token: 0x04000297 RID: 663
		private int _aesVer;

		// Token: 0x04000298 RID: 664
		private int _aesEncryptionStrength;

		// Token: 0x02000057 RID: 87
		[Flags]
		private enum Known : byte
		{
			// Token: 0x0400029A RID: 666
			None = 0,
			// Token: 0x0400029B RID: 667
			Size = 1,
			// Token: 0x0400029C RID: 668
			CompressedSize = 2,
			// Token: 0x0400029D RID: 669
			Crc = 4,
			// Token: 0x0400029E RID: 670
			Time = 8,
			// Token: 0x0400029F RID: 671
			ExternalAttributes = 16
		}
	}
}