public override void LoadSection(BinaryReaderEx reader)
        {
            base.LoadSection(reader);

            this.NumElements = reader.ReadInt32();
            reader.BaseStream.Seek(12, System.IO.SeekOrigin.Current); // Skip 12 bytes

            this.ElementOffsets = new List<ElementOffsetData>();

            for (var i = 0; i < this.NumElements; i++)
            {
                var thing = new ElementOffsetData();
                thing.BoneNameOffset = reader.ReadInt32();
                thing.NameOffset = reader.ReadInt32();
                thing.OffsetX = reader.ReadSingle();
                thing.OffsetY = reader.ReadSingle();
                thing.OffsetZ = reader.ReadSingle();
                thing.Unused1 = reader.ReadInt32();
                thing.Unused2 = reader.ReadInt32();
                thing.Unused3 = reader.ReadInt32();
                this.ElementOffsets.Add(thing);
            }

            foreach (var el in this.ElementOffsets)
            {
                reader.BaseStream.Position = this.SectionStart + el.BoneNameOffset;
                el.BoneName = reader.ReadNullTerminatedString();
                reader.BaseStream.Position = this.SectionStart + el.NameOffset;
                el.Name = reader.ReadNullTerminatedString();
            }
        }

        public override void LoadSection(BinaryReaderEx reader)
        {
            base.LoadSection(reader);

            this.MotionInfoBlocks = new List<MotionInfoBlock>();
            int numMIBs = (this.SectionLength - 4) / bytesPerBlock;
            for (var i = 0; i < numMIBs; i++)
            {
                var mib = new MotionInfoBlock();
                mib.MotionName = reader.ReadFixedLengthString(16).Trim();
                mib.FrameCount = reader.ReadSByte();
                mib.CurveCoefficient = reader.ReadSByte();
                mib.InitialVelocity = reader.ReadSByte();
                mib.RollingFrameEnd = reader.ReadSByte();
                mib.CaseOfRightFootEnd = reader.ReadSByte();
                mib.CaseOfLeftFootEnd = reader.ReadSByte();
                mib.Unk1 = reader.ReadSByte();
                mib.Unk2 = reader.ReadSByte();
                mib.SubstituteMotionName = reader.ReadFixedLengthString(16).Trim();
                mib.SubstituteMotionStartFrame = reader.ReadSByte();
                mib.IdleFramesToBlend = reader.ReadSByte();
                mib.FrameStartingRotationStop = reader.ReadSByte();
                mib.EndsOnWhichFoot = reader.ReadSByte();
                mib.Unknown = reader.ReadInt16();

                this.MotionInfoBlocks.Add(mib);
            }
        }

        public override void LoadData(BinaryReaderEx reader)
        {
            base.LoadData(reader);

            this.String = reader.ReadNullTerminatedString(Encoding.ASCII);
            this.DisplayName = "STR";
        }

        private void ReadHeader(BinaryReaderEx reader)
        {
            this.Header = new DatDigger.Sound.AdpcmWaveFormat();
            this.Header.FormatTag = (SlimDX.Multimedia.WaveFormatTag)reader.ReadInt16();
            this.Header.Channels = reader.ReadInt16();
            this.Header.SamplesPerSecond = reader.ReadInt32();
            this.Header.AverageBytesPerSecond = reader.ReadInt32();
            this.Header.BlockAlignment = reader.ReadInt16();
            this.Header.BitsPerSample = reader.ReadInt16();
            short cbSize = reader.ReadInt16();
            if (cbSize != 0x20)
            {
                throw new InvalidOperationException(String.Format("Unexpected value for ADPCMWAVEFORMAT cbSize 0x{0}.  Expected 0x20", cbSize));
            }

            this.Header.SamplesPerBlock = reader.ReadInt16();
            this.Header.NumCoef = reader.ReadInt16();
            this.Header.Coefficients = new List<DatDigger.Sound.AdpcmCoefficient>(this.Header.NumCoef);
            for (var i = 0; i < this.Header.NumCoef; i++)
            {
                DatDigger.Sound.AdpcmCoefficient coef = new DatDigger.Sound.AdpcmCoefficient();
                coef.A = reader.ReadInt16();
                coef.B = reader.ReadInt16();
                this.Header.Coefficients.Add(coef);
            }
        }

        public override void LoadSection(BinaryReaderEx reader)
        {
            base.LoadSection(reader);

            this.baseChunk = ChunkLoader.LoadChunk(SectionType.wrb, reader, this);
            this.Children = new List<INavigable>();
            this.Children.Add(baseChunk);
        }

        public override void LoadSection(BinaryReaderEx reader)
        {
            base.LoadSection(reader);

            this.LoadHeader(reader);
            this.LoadStringTable(reader);
            this.LoadBones(reader);
        }

        public void LoadFile(BinaryReaderEx reader)
        {
            reader.BaseStream.Seek(8, System.IO.SeekOrigin.Begin);

            this.ReadEncodedData(reader);
            this.DecodeData();

            this.Contents = Encoding.UTF8.GetString(this.decodedData);
        }

        public void LoadData(BinaryReaderEx reader)
        {
            reader.ReadInt32(); // Remove PWIB bytes
            this.FileSize = reader.ReadUInt32(Endianness.BigEndian);
            this.Unknown = reader.ReadInt32(Endianness.BigEndian);
            this.DataOffset = reader.ReadUInt32(Endianness.BigEndian);

            this.LoadSection(reader);
        }

        public void LoadData(BinaryReaderEx reader)
        {
            long pos = reader.BaseStream.Position;

            BuildFormat();

            reader.BaseStream.Position = pos + this.WaveHeader.FormatHeaderLength;
            this.WaveData = reader.ReadBytes(this.WaveHeader.DataLength);
        }

        public override void LoadSection(BinaryReaderEx reader)
        {
            base.LoadSection(reader);

            this.LoadHeader(reader);
            this.LoadResourceTypes(reader);
            this.LoadResourceIds(reader);
            this.LoadStringTable(reader);
            this.LoadResources(reader);
        }

        public virtual void LoadData(BinaryReaderEx reader)
        {
            this.ChunkStart = reader.BaseStream.Position;

            this.ChunkHeader = new ChunkHeader();
            this.ChunkHeader.ChunkType = reader.ReadInt32();
            this.ChunkHeader.Unknown1 = reader.ReadInt32(Endianness.BigEndian);
            this.ChunkHeader.DataSize = reader.ReadInt32(Endianness.BigEndian);
            this.ChunkHeader.NextChunkOffset = reader.ReadInt32(Endianness.BigEndian);
        }

        public virtual void LoadSection(BinaryReaderEx reader)
        {
            this.SectionStart = reader.BaseStream.Position;

            this.SectionHeader = new SectionHeader();
            this.SectionHeader.Magic = reader.ReadInt64();
            this.SectionHeader.Version = reader.ReadInt32();
            this.SectionHeader.Unknown2 = reader.ReadInt32();
            this.SectionHeader.SectionLength = reader.ReadInt32();
            this.SectionHeader.Junk = reader.ReadBytes(28);
        }

        public override void LoadSection(BinaryReaderEx reader)
        {
            base.LoadSection(reader);

            this.Strings = new List<string>();
            int numStrings = (this.SectionLength - 4) / bytesPerBlock;
            for (var i = 0; i < numStrings; i++)
            {
                this.Strings.Add(reader.ReadFixedLengthString(16).Trim());
            }
        }

        private void LoadHeader(BinaryReaderEx reader)
        {
            // Load Header
            this.ResourceHeader = new ResourceHeader();
            this.ResourceHeader.NumResources = reader.ReadInt32();
            this.ResourceHeader.StringTableOffset = reader.ReadInt32();
            this.ResourceHeader.NumStrings = reader.ReadInt32();
            this.ResourceHeader.ResourceType = (SectionType)reader.ReadInt32();

            this.LoadResourceInfo(reader);
        }

        public override void LoadData(BinaryReaderEx reader)
        {
            base.LoadData(reader);

            this.boundingBox.Minimum.X = reader.ReadSingle(Endianness.BigEndian);
            this.boundingBox.Minimum.Y = reader.ReadSingle(Endianness.BigEndian);
            this.boundingBox.Minimum.Z = reader.ReadSingle(Endianness.BigEndian);
            this.boundingBox.Maximum.X = reader.ReadSingle(Endianness.BigEndian);
            this.boundingBox.Maximum.Y = reader.ReadSingle(Endianness.BigEndian);
            this.boundingBox.Maximum.Z = reader.ReadSingle(Endianness.BigEndian);

            this.DisplayName = "AABB";
        }

        private void LoadHeader(BinaryReaderEx reader)
        {
            this.startHeaderOffset = reader.BaseStream.Position;

            this.SscfHeader = new SscfHeader();
            this.SscfHeader.Unknown0 = reader.ReadInt16();
            this.SscfHeader.NumTracks = reader.ReadInt16();
            this.SscfHeader.NumWaves = reader.ReadInt16();
            this.SscfHeader.Unknown1 = reader.ReadInt16();
            this.SscfHeader.OffsetA = reader.ReadInt32();
            this.SscfHeader.OffsetB = reader.ReadInt32();
            this.SscfHeader.OffsetC = reader.ReadInt64();
            this.SscfHeader.OffsetD = reader.ReadInt64();
            this.SscfHeader.OffsetE = reader.ReadInt64();
            this.SscfHeader.Unused = reader.ReadInt64();
        }

        public override void LoadSection(BinaryReaderEx reader)
        {
            base.LoadSection(reader);

            this.CibtData = new List<CibtData>();
            int numCibtBlocks = (this.SectionLength - 4) / bytesPerBlock;
            for (var i = 0; i < numCibtBlocks; i++)
            {
                var cibt = new CibtData();
                cibt.Name = reader.ReadFixedLengthString(16).Trim();
                cibt.Unk1 = reader.ReadByte();
                cibt.Unk2 = reader.ReadByte();
                cibt.Unk3 = reader.ReadByte();
                cibt.Unk4 = reader.ReadByte();
                this.CibtData.Add(cibt);
            }
        }

        public override void LoadSection(BinaryReaderEx reader)
        {
            base.LoadSection(reader);

            for (var i = 0; i < this.NumChildren; i++)
            {
                StringEntry entry = new StringEntry()
                {
                    StringIndex = reader.ReadInt16(),
                    Value = reader.ReadInt16(),
                    Parent = this
                };

                entry.DisplayName = entry.StringIndex.ToString();
                this.Children.Add(entry);
            }
        }

        private void LoadVoices(BinaryReaderEx reader)
        {
            if (this.SscfHeader.NumWaves <= 0)
            {
                return;
            }

            reader.BaseStream.Position = this.SscfHeader.OffsetB;
            this.VoiceOffsets = new List<int>(this.SscfHeader.NumWaves);
            this.Children = new List<INavigable>(this.SscfHeader.NumWaves);

            for (var i = 0; i < this.SscfHeader.NumWaves; i++)
            {
                this.VoiceOffsets.Add(reader.ReadInt32());
            }

            foreach (int offset in this.VoiceOffsets)
            {
                reader.BaseStream.Position = offset;
                WaveHeader waveHeader = ReadWaveHeader(reader);
                IWave voice = null;
                switch (waveHeader.Format)
                {
                    case WaveCompressionFormat.PCM:
                        voice = new PcmWave() { Parent = this, WaveHeader = waveHeader };
                        break;
                    case WaveCompressionFormat.Vorbis:
                        voice = new VorbisWave() { Parent = this, WaveHeader = waveHeader };
                        break;
                    case WaveCompressionFormat.ADPCM:
                        voice = new AdpcmWave() { Parent = this, WaveHeader = waveHeader };
                        break;
                    case WaveCompressionFormat.ATRAC3:
                    case WaveCompressionFormat.ATRAC3_Too:
                    case WaveCompressionFormat.XMA:
                        throw new InvalidOperationException("Unsupported Wave Format: " + waveHeader.Format);
                    default:
                        throw new InvalidOperationException("Unknown Wave Format: 0x" + ((int)waveHeader.Format).ToString("X"));
                }

                this.Children.Add(voice);
                voice.LoadData(reader);
            }
        }

        public override void Load(BinaryReaderEx reader)
        {
            base.Load(reader);

            Float1 = reader.ReadSingle();
            AnimationLength = reader.ReadSingle();
            Bones = reader.ReadInt16();
            NumIndices = reader.ReadInt16();
            Flags = reader.ReadByte();
            reader.BaseStream.Seek(3, System.IO.SeekOrigin.Current);
            for (var i = 0; i < NumIndices; i++)
            {
                int val = reader.ReadInt32();
                ChunkIndex idx = new ChunkIndex();
                idx.Index = val & 0x7FFFFFFF;
                idx.Flag = (val & 0x80000000) == 0x80000000;
                this.Offsets.Add(idx);
            }
        }