protected static byte[] Decompress(byte[] decrypted, IBinaryReader reader, byte[] key, int keyMod) {
				int destIndex = 0;
				while (reader.Position < reader.Length) {
					if (destIndex >= decrypted.Length)
						break;
					byte flags = reader.ReadByte();
					for (int mask = 1; mask != 0x100; mask <<= 1) {
						if (reader.Position >= reader.Length)
							break;
						if (destIndex >= decrypted.Length)
							break;
						if ((flags & mask) != 0) {
							int displ = (int)reader.Read7BitEncodedUInt32();
							int size = (int)reader.Read7BitEncodedUInt32();
							Copy(decrypted, destIndex - displ, decrypted, destIndex, size);
							destIndex += size;
						}
						else {
							byte b = reader.ReadByte();
							if (key != null)
								b ^= key[destIndex % keyMod];
							decrypted[destIndex++] = b;
						}
					}
				}

				return decrypted;
			}

 /** <inheritDoc /> */
 public void ReadBinary(IBinaryReader reader)
 {
     StreetNumber = reader.ReadInt("streetNum");
     FlatNumber = reader.ReadInt("flatNum");
     City = reader.ReadString("city");
     Street = reader.ReadString("street");
 }

 /** <inheritDoc /> */
 public void ReadBinary(IBinaryReader reader)
 {
     Byte = reader.ReadByte("Byte");
     ByteArray = reader.ReadByteArray("ByteArray");
     Char = reader.ReadChar("Char");
     CharArray = reader.ReadCharArray("CharArray");
     Short = reader.ReadShort("Short");
     ShortArray = reader.ReadShortArray("ShortArray");
     Int = reader.ReadInt("Int");
     IntArray = reader.ReadIntArray("IntArray");
     Long = reader.ReadLong("Long");
     LongArray = reader.ReadLongArray("LongArray");
     Boolean = reader.ReadBoolean("Boolean");
     BooleanArray = reader.ReadBooleanArray("BooleanArray");
     Float = reader.ReadFloat("Float");
     FloatArray = reader.ReadFloatArray("FloatArray");
     Double = reader.ReadDouble("Double");
     DoubleArray = reader.ReadDoubleArray("DoubleArray");
     Decimal = reader.ReadDecimal("Decimal");
     DecimalArray = reader.ReadDecimalArray("DecimalArray");
     Date = reader.ReadTimestamp("Date");
     DateArray = reader.ReadTimestampArray("DateArray");
     String = reader.ReadString("String");
     StringArray = reader.ReadStringArray("StringArray");
     Guid = reader.ReadObject<Guid>("Guid");
     GuidArray = reader.ReadGuidArray("GuidArray");
 }

		static bool ReadHeader(IBinaryReader reader, out ushort flags, out uint codeSize) {
			byte b = reader.ReadByte();
			switch (b & 7) {
			case 2:
			case 6:
				flags = 2;
				codeSize = (uint)(b >> 2);
				return true;

			case 3:
				flags = (ushort)((reader.ReadByte() << 8) | b);
				uint headerSize = (byte)(flags >> 12);
				ushort maxStack = reader.ReadUInt16();
				codeSize = reader.ReadUInt32();
				uint localVarSigTok = reader.ReadUInt32();

				reader.Position += -12 + headerSize * 4;
				if (headerSize < 3)
					flags &= 0xFFF7;
				return true;

			default:
				flags = 0;
				codeSize = 0;
				return false;
			}
		}

        internal void Deserialize(IBinaryReader reader, int count)
        {
            for (int i = 0; i < count; i++)
            {
				_excerpts.Add(reader.ReadString());
            }
        }

 ///<summary>
 ///</summary>
 ///<param name = "reader"></param>
 public BinaryPropertyDeserializer(IBinaryReader reader)
 {
     if (reader == null) {
         throw new ArgumentNullException("reader");
     }
     _reader = reader;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="ComputeFuncJob"/> class.
        /// </summary>
        /// <param name="reader">The reader.</param>
        public ComputeFuncJob(IBinaryReader reader)
        {
            var reader0 = (BinaryReader) reader.GetRawReader();

            _clo = reader0.ReadObject<IComputeFunc>();
            _arg = reader0.ReadObject<object>();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ContinuousQueryFilterHolder"/> class.
        /// </summary>
        /// <param name="reader">The reader.</param>
        public ContinuousQueryFilterHolder(IBinaryReader reader)
        {
            var rawReader = (BinaryReader) reader.GetRawReader();

            _filter = rawReader.ReadObject<object>();
            _keepBinary = rawReader.ReadBoolean();
        }

        internal void Deserialize(IBinaryReader reader, MatchParseContext context)
        {
            _docId = (context.LongIdentifiers) ? reader.ReadInt64() : reader.ReadInt32();
            _weight = reader.ReadInt32();

            AttributesValues.Deserialize(reader, context);
        }

		public static MethodBodyHeader ParseMethodBody(IBinaryReader reader, out byte[] code, out byte[] extraSections) {
			try {
				return ParseMethodBody2(reader, out code, out extraSections);
			}
			catch (IOException) {
				throw new InvalidMethodBody();
			}
		}

 public OperationDataMapper(IXmlReader xmlReader, IBinaryReader binaryReader, ISpatialRecordMapper spatialRecordMapper, ISectionMapper sectionMapper, IUniqueIdMapper uniqueIdMapper)
 {
     _spatialRecordMapper = spatialRecordMapper;
     _sectionMapper = sectionMapper;
     _uniqueIdMapper = uniqueIdMapper;
     _xmlReader = xmlReader;
     _binaryReader = binaryReader;
 }

		/// <summary>
		/// Reads the column
		/// </summary>
		/// <param name="reader">A reader positioned on this column</param>
		/// <returns>The column value</returns>
		public uint Read(IBinaryReader reader) {
			switch (size) {
			case 1: return reader.ReadByte();
			case 2: return reader.ReadUInt16();
			case 4: return reader.ReadUInt32();
			default: throw new InvalidOperationException("Invalid column size");
			}
		}

		internal void Deserialize(IBinaryReader reader)
		{
			FlushTag = reader.ReadInt32();
			if (FlushTag < 0)
			{
				throw new SphinxException(String.Format(Messages.Exception_CouldNotFlushIndexAttributeValues, FlushTag));
			}
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="SerializableObjectHolder"/> class.
        /// </summary>
        /// <param name="reader">The reader.</param>
        public SerializableObjectHolder(IBinaryReader reader)
        {
            Debug.Assert(reader != null);

            var reader0 = (BinaryReader) reader.GetRawReader();

            _item = new BinaryFormatter().Deserialize(new BinaryStreamAdapter(reader0.Stream), null);
        }

		ResourceReader(ModuleDef module, IBinaryReader reader, CreateResourceDataDelegate createResourceDataDelegate) {
			this.reader = reader;
			this.resourceDataCreator = new ResourceDataCreator(module);
			this.createResourceDataDelegate = createResourceDataDelegate;

			var stream = reader as IImageStream;
			this.baseFileOffset = stream == null ? 0 : (long)stream.FileOffset;
		}

 static uint readUInt32(IBinaryReader reader)
 {
     try {
         return reader.Read7BitEncodedUInt32();
     }
     catch {
         throw new ResourceReaderException("Invalid encoded int32");
     }
 }

        /// <summary>
        /// Read binary object.
        /// </summary>
        /// <param name="obj">Instantiated empty object.</param>
        /// <param name="reader">Reader.</param>
        /// <exception cref="BinaryObjectException">Type is not registered in serializer:  + type.Name</exception>
        public void ReadBinary(object obj, IBinaryReader reader)
        {
            var binarizable = obj as IBinarizable;

            if (binarizable != null)
                binarizable.ReadBinary(reader);
            else
                GetDescriptor(obj).Read(obj, reader);
        }

        internal void Deserialize(IBinaryReader reader, int count)
        {
            for (int i = 0; i < count; i++)
            {
                SearchQueryResult result = new SearchQueryResult();
                result.Deserialize(reader);
				_queryResults.Add(result);
            }
        }

 public static byte[] readExtraSections(IBinaryReader reader)
 {
     try {
         return readExtraSections2(reader);
     }
     catch (IOException) {
         throw new InvalidMethodBody();
     }
 }

 CustomAttributeReader(ModuleDef module, IBinaryReader reader, bool ownRerader)
 {
     this.module = module;
     this.reader = reader;
     this.ownReader = ownRerader;
     this.genericArguments = null;
     this.recursionCounter = new RecursionCounter();
     this.verifyReadAllBytes = false;
 }