public void Deserialize( IUnrealStream stream )
 {
     UncompressedOffset = stream.ReadInt32();
     UncompressedSize = stream.ReadInt32();
     CompressedOffset = stream.ReadInt32();
     CompressedSize = stream.ReadInt32();
 }

 public void Deserialize( IUnrealStream stream )
 {
     FileName = stream.ReadText();
     SerialOffset = (uint)stream.ReadIndex();
     SerialSize = (uint)stream.ReadIndex();
     FileFlags = stream.ReadUInt32();
 }

        public void Deserialize( IUnrealStream stream )
        {
            Name = stream.ReadText();

            // Mass effect 2
            if (stream.Version == 512)
            {
                Flags = stream.ReadUInt32();
            }
            else
            {
                Flags = stream.Version >= QWORDVersion ? stream.ReadUInt64() : stream.ReadUInt32();
            }
            #if DEOBFUSCATE
            // De-obfuscate names that contain unprintable characters!
            foreach( char c in Name )
            {
                if( !char.IsLetterOrDigit( c ) )
                {
                    Name = "N" + TableIndex + "_OBF";
                    break;
                }
            }
            #endif
        }

                public override void Deserialize( IUnrealStream stream )
                {
                    CastedObject = stream.ReadObject();
                    Decompiler.AlignObjectSize();

                    base.Deserialize( stream );
                }

 public void Serialize(IUnrealStream stream)
 {
     stream.Serialize(ref this.PowerName);
     stream.Serialize(ref this.CurrentRank);
     stream.Serialize(ref this.PowerClassName);
     stream.Serialize(ref this.WheelDisplayIndex);
 }

 public void Serialize(IUnrealStream stream)
 {
     stream.Serialize(ref this.SecondsSinceMidnight);
     stream.Serialize(ref this.Day);
     stream.Serialize(ref this.Month);
     stream.Serialize(ref this.Year);
 }

 public void Serialize(IUnrealStream stream)
 {
     stream.Serialize(ref this.R);
     stream.Serialize(ref this.G);
     stream.Serialize(ref this.B);
     stream.Serialize(ref this.A);
 }

                public override void Deserialize( IUnrealStream stream )
                {
                    // Key
                    DeserializeNext();

                    // Array
                    DeserializeNext();
                }

 public void Serialize( IUnrealStream stream )
 {
     // TODO: Implement code
     stream.Write( UncompressedOffset );
     stream.Write( UncompressedSize );
     stream.Write( CompressedOffset );
     stream.Write( CompressedSize );
 }

 public void Serialize( IUnrealStream stream )
 {
     Console.WriteLine( "Writing import " + ObjectName + " at " + stream.Position );
     stream.Write( PackageName );
     stream.Write( _ClassName );
     stream.Write( OuterTable != null ? (int)OuterTable.Object : 0 ); // Always an ordinary integer
     stream.Write( ObjectName );
 }

        public void Deserialize( IUnrealStream stream )
        {
            var index = stream.ReadNameIndex( out _Number );
            _NameItem = stream.Package.Names[index];

            Debug.Assert( _NameItem != null, "_NameItem cannot be null! " + index );
            Debug.Assert( _Number >= -1, "Invalid _Number value! " + _Number );
        }

                public override void Deserialize( IUnrealStream stream )
                {
                    // TODO: Corrigate version.
                    if( stream.Version <= 300 )
                        return;

                    _ReturnObject = Decompiler._Container.TryGetIndexObject( stream.ReadObjectIndex() );
                    Decompiler.AlignObjectSize();
                }

 public void Deserialize( IUnrealStream stream )
 {
     Console.WriteLine( "Reading import " + Index + " at " + stream.Position );
     PackageName         = stream.ReadNameReference();
     _ClassName          = stream.ReadNameReference();
     ClassIndex         = (int)_ClassName;
     OuterIndex          = stream.ReadInt32(); // ObjectIndex, though always written as 32bits regardless of build.
     ObjectName          = stream.ReadNameReference();
 }

                public override void Deserialize( IUnrealStream stream )
                {
                    stream.ReadObjectIndex();
                    Decompiler.AlignObjectSize();

                    DeserializeNext();
                    // ==
                    DeserializeNext();
                }

 public void Serialize(IUnrealStream stream)
 {
     stream.Serialize(ref this.Unknown0);
     stream.Serialize(ref this.Unknown1);
     stream.Serialize(ref this.Unknown2);
     stream.Serialize(ref this.Unknown3);
     stream.Serialize(ref this.Unknown4);
     stream.Serialize(ref this.Unknown5);
 }

 public void Serialize( IUnrealStream stream )
 {
     stream.Write( ExportsCount );
     stream.Write( NamesCount );
     if( stream.Version >= VNetObjectsCount )
     {
         stream.Write( NetObjectsCount );
     }
 }

 public void Serialize( IUnrealStream stream )
 {
     stream.WriteIndex( _Index );
     if( stream.Version >= VNameNumbered )
     {
         Console.WriteLine( _Number + " " + _Text );
         stream.Write( (uint)_Number + 1 );
     }
 }

            public void Deserialize( IUnrealStream stream )
            {
                _StartU = stream.ReadInt32();
                _StartV = stream.ReadInt32();

                _USize = stream.ReadInt32();
                _VSize = stream.ReadInt32();

                _TextureIndex = stream.ReadByte();
            }

            public void Deserialize( IUnrealStream stream )
            {
                Class = stream.ReadObjectIndex();

                // Deep
                stream.ReadInt32();

                // ScriptTextCRC
                stream.ReadUInt32();
            }

        public List<int> CodexIDs; // +4C

        public void Serialize(IUnrealStream stream)
        {
            stream.Serialize(ref this.BoolVariables);
            stream.Serialize(ref this.IntVariables);
            stream.Serialize(ref this.FloatVariables);
            stream.Serialize(ref this.QuestProgressCounter);
            stream.Serialize(ref this.QuestProgress);
            stream.Serialize(ref this.QuestIDs);
            stream.Serialize(ref this.CodexEntries);
            stream.Serialize(ref this.CodexIDs);
        }