diff --git a/EveryFileExplorer.sln b/EveryFileExplorer.sln
index 9acf359..19887fc 100644
--- a/EveryFileExplorer.sln
+++ b/EveryFileExplorer.sln
@@ -21,6 +21,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MarioKart", "MarioKart\MarioKart.csproj", "{8117CF39-0FD6-453D-AA7F-4B4AD85EBB3A}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LegoPirates", "LegoPirates\LegoPirates.csproj", "{E786AAC6-2D88-40E0-BFB6-45164A6183F9}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -101,6 +103,16 @@ Global
 		{8117CF39-0FD6-453D-AA7F-4B4AD85EBB3A}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{8117CF39-0FD6-453D-AA7F-4B4AD85EBB3A}.Release|Mixed Platforms.Build.0 = Release|Any CPU
 		{8117CF39-0FD6-453D-AA7F-4B4AD85EBB3A}.Release|x86.ActiveCfg = Release|Any CPU
+		{E786AAC6-2D88-40E0-BFB6-45164A6183F9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E786AAC6-2D88-40E0-BFB6-45164A6183F9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E786AAC6-2D88-40E0-BFB6-45164A6183F9}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{E786AAC6-2D88-40E0-BFB6-45164A6183F9}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{E786AAC6-2D88-40E0-BFB6-45164A6183F9}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{E786AAC6-2D88-40E0-BFB6-45164A6183F9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E786AAC6-2D88-40E0-BFB6-45164A6183F9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E786AAC6-2D88-40E0-BFB6-45164A6183F9}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{E786AAC6-2D88-40E0-BFB6-45164A6183F9}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{E786AAC6-2D88-40E0-BFB6-45164A6183F9}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/EveryFileExplorer/EveryFileExplorer.csproj b/EveryFileExplorer/EveryFileExplorer.csproj
index 5e7116a..c732812 100644
--- a/EveryFileExplorer/EveryFileExplorer.csproj
+++ b/EveryFileExplorer/EveryFileExplorer.csproj
@@ -96,6 +96,10 @@
     <Content Include="Propeller_Box_Artwork_-_Super_Mario_3D_World.ico" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>md "$(TargetDir)\Plugins"
+copy "$(SolutionDir)\Libraries\*" "$(TargetDir)\Plugins"</PreBuildEvent>
+  </PropertyGroup>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/EveryFileExplorer/Plugins/PluginManager.cs b/EveryFileExplorer/Plugins/PluginManager.cs
index 7492481..f356216 100644
--- a/EveryFileExplorer/Plugins/PluginManager.cs
+++ b/EveryFileExplorer/Plugins/PluginManager.cs
@@ -25,7 +25,15 @@ namespace EveryFileExplorer.Plugins
 				{
 					continue;//This is not a .net assembly
 				}
-				Assembly ass = Assembly.LoadFile(s);
+				Assembly ass = null;
+				try
+				{
+					ass = Assembly.LoadFile(s);
+				}
+				catch(NotSupportedException e)
+				{
+					MessageBox.Show("Unblock " + AssemblyName.GetAssemblyName(s) + " from external sources!");
+				}
 				if (Plugin.IsPlugin(ass)) p.Add(new Plugin(ass));
 			}
 			Plugins = p.ToArray();
diff --git a/LegoPirates/FMV.cs b/LegoPirates/FMV.cs
new file mode 100644
index 0000000..8c9de1b
--- /dev/null
+++ b/LegoPirates/FMV.cs
@@ -0,0 +1,1256 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using LibEveryFileExplorer.Files;
+using LibEveryFileExplorer.IO;
+using System.Drawing;
+
+namespace LegoPirates
+{
+	public class FMV : FileFormat<FMV.FMVIdentifier>, IViewable
+	{
+		private readonly static byte[] QuantizationGenerationTable1 = {
+			0x10, 0x10, 0x10, 0x10, 0x11, 0x12, 0x15, 0x18, 0x10, 0x10, 0x10, 0x10,
+			0x11, 0x13, 0x16, 0x19, 0x10, 0x10, 0x11, 0x12, 0x14, 0x16, 0x19, 0x1D,
+			0x10, 0x10, 0x12, 0x15, 0x18, 0x1B, 0x1F, 0x24, 0x11, 0x11, 0x14, 0x18,
+			0x1E, 0x23, 0x29, 0x2F, 0x12, 0x13, 0x16, 0x1B, 0x23, 0x2C, 0x36, 0x41,
+			0x15, 0x16, 0x19, 0x1F, 0x29, 0x36, 0x46, 0x58, 0x18, 0x19, 0x1D, 0x24,
+			0x2F, 0x41, 0x58, 0x73, 0x11, 0x12, 0x18, 0x2F, 0x63, 0x63, 0x63, 0x63,
+			0x12, 0x15, 0x1A, 0x42, 0x63, 0x63, 0x63, 0x63, 0x18, 0x1A, 0x38, 0x63,
+			0x63, 0x63, 0x63, 0x63, 0x2F, 0x42, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+			0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+			0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+			0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63
+		};
+
+		private readonly static byte[] QuantizationGenerationTable2 = {
+			0x10, 0x0B, 0x0A, 0x10, 0x18, 0x28, 0x33, 0x3D, 0x0C, 0x0C, 0x0E, 0x13,
+			0x1A, 0x3A, 0x3C, 0x37, 0x0E, 0x0D, 0x10, 0x18, 0x28, 0x39, 0x45, 0x38,
+			0x0E, 0x11, 0x16, 0x1D, 0x33, 0x57, 0x50, 0x3E, 0x12, 0x16, 0x25, 0x38,
+			0x44, 0x6D, 0x67, 0x4D, 0x18, 0x23, 0x37, 0x40, 0x51, 0x68, 0x71, 0x5C,
+			0x31, 0x40, 0x4E, 0x57, 0x67, 0x79, 0x78, 0x65, 0x48, 0x5C, 0x5F, 0x62,
+			0x70, 0x64, 0x67, 0x63, 0x11, 0x12, 0x18, 0x2F, 0x63, 0x63, 0x63, 0x63,
+			0x12, 0x15, 0x1A, 0x42, 0x63, 0x63, 0x63, 0x63, 0x18, 0x1A, 0x38, 0x63,
+			0x63, 0x63, 0x63, 0x63, 0x2F, 0x42, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+			0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+			0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
+			0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63
+		};
+
+		private readonly static uint[] AnotherQuantizationGenerationTable = {
+			0x10000,
+			0x16315,
+			0x14E7B,
+			0x12D06,
+			0x10000,
+			0xC923,
+			0x8A8C,
+			0x46A1
+		};
+
+		private readonly static byte[] ZigZagTable = {
+			0x00, 0x08, 0x01, 0x02, 0x09, 0x10, 0x18, 0x11, 0x0A, 0x03, 0x04, 0x0B,
+			0x12, 0x19, 0x20, 0x28, 0x21, 0x1A, 0x13, 0x0C, 0x05, 0x06, 0x0D, 0x14,
+			0x1B, 0x22, 0x29, 0x30, 0x38, 0x31, 0x2A, 0x23, 0x1C, 0x15, 0x0E, 0x07,
+			0x0F, 0x16, 0x1D, 0x24, 0x2B, 0x32, 0x39, 0x3A, 0x33, 0x2C, 0x25, 0x1E,
+			0x17, 0x1F, 0x26, 0x2D, 0x34, 0x3B, 0x3C, 0x35, 0x2E, 0x27, 0x2F, 0x36,
+			0x3D, 0x3E, 0x37, 0x3F
+		};
+		private FMVInfo Info;
+
+		public FMV(byte[] Data)
+		{
+			EndianBinaryReader er = new EndianBinaryReader(new MemoryStream(Data), Endianness.LittleEndian);
+			try
+			{
+				Header = new FMVHeader(er);
+				Info = new FMVInfo(this, er);
+			}
+			catch
+			{
+				er.Close();
+			}
+		}
+
+		public System.Windows.Forms.Form GetDialog()
+		{
+			return new UI.FMVViewer(this);
+		}
+
+		public FMVHeader Header;
+		public class FMVHeader
+		{
+			public FMVHeader(EndianBinaryReader er)
+			{
+				Signature = er.ReadString(Encoding.ASCII, 4);
+				if (Signature != "FMV!") throw new SignatureNotCorrectException(Signature, "FMV!", er.BaseStream.Position - 4);
+				Version = er.ReadUInt16();
+				HeaderLength = er.ReadUInt16();
+				Width = er.ReadUInt16();
+				Height = er.ReadUInt16();
+				NrBlocks = er.ReadUInt32();
+				Unknown1 = er.ReadUInt32();
+				FrameRate = er.ReadUInt16();
+				Flags = er.ReadUInt32();
+				Unknown2 = er.ReadUInt32();
+				if ((Flags & 4) == 4)
+				{
+					Unknown3 = er.ReadUInt16();
+					AudioRate = er.ReadUInt32();
+					Unknown4 = er.ReadByte();
+					Unknown5 = er.ReadByte();
+					Unknown6 = er.ReadByte();
+					Unknown7 = er.ReadByte();
+				}
+			}
+			public String Signature;
+			public UInt16 Version;
+			public UInt16 HeaderLength;
+			public UInt16 Width;
+			public UInt16 Height;
+			public UInt32 NrBlocks;
+			public UInt32 Unknown1;
+			public UInt16 FrameRate;
+			public UInt32 Flags;
+			public UInt32 Unknown2;
+			//If Flags & 4, means audio
+			public UInt16 Unknown3;
+			public UInt32 AudioRate;
+			public Byte Unknown4;
+			public Byte Unknown5;
+			public Byte Unknown6;
+			public Byte Unknown7;
+		}
+
+		private class FMVk
+		{
+			public FMVk(FMVInfo Info, bool Tables)
+			{
+				Signature = Info.er.ReadString(Encoding.ASCII, 4);
+				if (Signature != "FMVk") throw new SignatureNotCorrectException(Signature, "FMVk", Info.er.BaseStream.Position - 4);
+				SectionSize = Info.er.ReadUInt32();
+				FrameBlockDataSize = Info.er.ReadUInt16();
+				FrameBlockData = DecompressRLE(Info.er.ReadBytes(FrameBlockDataSize), 0, FrameBlockDataSize);
+				Quality = Info.er.ReadByte();
+				int total = 0;
+				if (Tables)
+				{
+					TableInfo1a = Info.er.ReadBytes(16);
+					int q = 0;
+					foreach (byte b in TableInfo1a) q += b;
+					Table1a = Info.er.ReadBytes(q);
+					total += q + 16;
+					TableInfo2a = Info.er.ReadBytes(16);
+					q = 0;
+					foreach (byte b in TableInfo2a) q += b;
+					Table2a = Info.er.ReadBytes(q);
+					total += q + 16;
+					TableInfo1b = Info.er.ReadBytes(16);
+					q = 0;
+					foreach (byte b in TableInfo1b) q += b;
+					Table1b = Info.er.ReadBytes(q);
+					total += q + 16;
+					TableInfo2b = Info.er.ReadBytes(16);
+					q = 0;
+					foreach (byte b in TableInfo2b) q += b;
+					Table2b = Info.er.ReadBytes(q);
+					total += q + 16;
+					ReadTable(Info, TableInfo1a, Table1a, 0, 0);
+					ReadTable(Info, TableInfo2a, Table2a, 1, 0);
+					ReadTable(Info, TableInfo1b, Table1b, 0, 1);
+					ReadTable(Info, TableInfo2b, Table2b, 1, 1);
+				}
+				FrameData = Info.er.ReadBytes((int)SectionSize - 3 - FrameBlockDataSize - total);//(Tables ? 0x19C : 0));
+			}
+			public String Signature;
+			public UInt32 SectionSize;
+			public UInt16 FrameBlockDataSize;
+			public byte[] FrameBlockData;
+			public byte Quality;
+
+			public byte[] TableInfo1a;
+			public byte[] Table1a;
+			public byte[] TableInfo2a;
+			public byte[] Table2a;
+			public byte[] TableInfo1b;
+			public byte[] Table1b;
+			public byte[] TableInfo2b;
+			public byte[] Table2b;
+
+			public byte[] FrameData;
+
+			private void ReadTable(FMVInfo Info, byte[] TableInfo, byte[] Table, int r1, int r2)
+			{
+				if (r1 == 1)
+				{
+					CreateTables(ref Info.field_1200[r2], ref Info.field_1600[r2], ref Info.field_1900[r2], ref Info.field_1A04[r2], ref Info.field_1A4C[r2], TableInfo);
+					Info.field_1800[r2] = new byte[Table.Length];
+					Array.Copy(Table, Info.field_1800[r2], Table.Length);
+				}
+				else
+				{
+					CreateTables(ref Info.field_0[r2], ref Info.field_400[r2], ref Info.field_700[r2], ref Info.field_804[r2], ref Info.field_84C[r2], TableInfo);
+					Info.field_600[r2] = new byte[Table.Length];
+					Array.Copy(Table, Info.field_600[r2], Table.Length);
+				}
+			}
+
+			private void CreateTables(ref byte[] Table0x0, ref ushort[] Table0x400, ref byte[] Table0x700, ref uint[] Table0x804, ref uint[] Table0x84C, byte[] TableInfo)
+			{
+				List<byte> data = new List<byte>();
+				for (int i = 0; i < 16; i++)
+				{
+					for (int j = 0; j < TableInfo[i]; j++)
+					{
+						data.Add((byte)((i + 1) & 0xFF));
+					}
+				}
+				data.Add(0);
+				Table0x700 = data.ToArray();
+				Table0x804 = new uint[18];
+				Table0x84C = new uint[18];
+				List<ushort> table0x400 = new List<ushort>();
+				uint v7 = 0;
+				int v8 = 0;
+				int v9 = 1;
+				do
+				{
+					for (Table0x84C[v9] = (uint)(v8 - v7); v9 == Table0x700[v8]; table0x400.Add((ushort)v7++), v8++) ;
+					uint v10 = v7 << (16 - v9);
+					Table0x804[v9++] = v10;
+					v7 *= 2;
+				}
+				while (v9 <= 16);
+				Table0x804[v9] = 0xFFFFFFFF;
+				Table0x400 = table0x400.ToArray();
+				Table0x0 = new byte[0x400];
+				//This just fills with 0xFF
+				//ushort[] _data = new ushort[0x200];
+				//sub_213474C(ref _data, 0xFF, 0x400);
+				for (int i = 0; i < 0x400; i++)
+				{
+					Table0x0[i] = 0xFF;
+				}
+				for (int i = 0; i < v8; i++)
+				{
+					int v13 = Table0x700[i];
+					if (v13 <= 10)
+					{
+						int v14 = 10 - v13;
+						int v15 = 1 << v14;
+						int v16 = 0;
+						int v17 = Table0x400[i];
+						if (1 << v14 > 0)
+						{
+							do
+							{
+								Table0x0[(v17 << v14) + v16++] = (byte)i;
+							}
+							while (v16 < v15);
+						}
+					}
+				}
+			}
+		}
+
+		private class FMVd
+		{
+			public FMVd(FMVInfo Info)
+			{
+				Signature = Info.er.ReadString(Encoding.ASCII, 4);
+				if (Signature != "FMVd") throw new SignatureNotCorrectException(Signature, "FMVd", Info.er.BaseStream.Position - 4);
+				SectionSize = Info.er.ReadUInt32();
+				FrameBlockDataSize = Info.er.ReadUInt16();
+				FrameBlockData = DecompressRLE(Info.er.ReadBytes(FrameBlockDataSize), 0, FrameBlockDataSize);
+				Marker = Info.er.ReadByte();
+				FrameData = Info.er.ReadBytes((int)SectionSize - 3 - FrameBlockDataSize);
+			}
+			public String Signature;
+			public UInt32 SectionSize;
+			public UInt16 FrameBlockDataSize;
+			public byte[] FrameBlockData;
+			public byte Marker;//?
+			public byte[] FrameData;
+		}
+
+		public Bitmap GetNextFrame(out byte[] Audio)
+		{
+			if (Info.er != null && Info.er.BaseStream.Position >= Info.er.BaseStream.Length)
+			{
+				Info.er.Close();
+				Info.er = null;
+				Audio = null;
+				return null;
+			}
+			Audio = null;
+			String s = Info.er.ReadString(Encoding.ASCII, 4);
+			Info.er.BaseStream.Position -= 4;
+			switch (s)
+			{
+				case "FMVk":
+					{
+						var v = new FMVk(Info, Info.FirstKeyFrame);
+						Info.FirstKeyFrame = false;
+						GenerateQuantizationTables(Info, v.Quality);
+						Info.LastFrame = ToBitmap(Info, v.FrameBlockData, v.FrameData);
+						return Info.LastFrame;
+					}
+				case "FMVd":
+					{
+						var v = new FMVd(Info);
+						GenerateQuantizationTables(Info, v.Marker);
+						Info.LastFrame = ToBitmap(Info, v.FrameBlockData, v.FrameData);
+						return Info.LastFrame;
+					}
+				case "FMVn":
+					Info.er.BaseStream.Position += 8;
+					return Info.LastFrame;
+				case "FMA\0":
+					Info.er.BaseStream.Position += 4;
+					int length = (int)Info.er.ReadUInt32();
+					Audio = Info.er.ReadBytes(length);
+					return null;
+				default:
+					return null;
+			}
+		}
+
+		public void Close()
+		{
+			if (Info.er != null)
+			{
+				Info.er.Close();
+				Info.er = null;
+			}
+		}
+
+		private static void GenerateQuantizationTables(FMVInfo Info, uint Quality)
+		{
+			uint r0;
+			uint r1 = Quality;
+			uint r2;
+			uint r3;
+			uint r4;
+			uint r6;
+			uint r7;
+			uint r8;
+			uint r11;
+			uint r12;
+			uint lr;
+
+			byte[] QuantizationGenerationTable = QuantizationGenerationTable1;//If 16 bit at offset 4 in header == 0x113
+
+			Info.QuantizationTables[0] = new uint[64];
+			Info.QuantizationTables[1] = new uint[64];
+
+			if (r1 <= 0) r1 = 1;
+			if (r1 > 100) r1 = 100;
+			if (r1 >= 50)
+			{
+				r0 = r1 << 1;
+				r0 = 0xC8 - r0;
+			}
+			else
+			{
+				r0 = 0x1388 / r1;
+				//r0 = 0; 
+			}
+			r7 = 0;
+			while (true)
+			{
+				r6 = 0;
+				r1 = 0x51EB851F;
+				r11 = 1;
+				while (true)
+				{
+					r2 = QuantizationGenerationTable[64 * r7 + r6];
+					r4 = (uint)((int)r6 >> 3);
+					r12 = r6 & 7;
+					r2 = r0 * r2;
+					r3 = r2 + 0x32;
+
+					ulong tmpl = (ulong)(((long)(int)r1) * ((long)(int)r3));
+					r2 = (uint)(tmpl & 0xFFFFFFFF);
+					r8 = (uint)((tmpl >> 32) & 0xFFFFFFFF);
+
+					r2 = r3 >> 31;
+					r3 = AnotherQuantizationGenerationTable[r12];
+					lr = AnotherQuantizationGenerationTable[r4];
+					r8 = r2 + (uint)((int)r8 >> 5);
+
+					tmpl = (ulong)(((long)(int)lr) * ((long)(int)r3));
+					r12 = (uint)(tmpl & 0xFFFFFFFF);
+					r3 = (uint)((tmpl >> 32) & 0xFFFFFFFF);
+
+					if (r8 <= 0) r8 = r11;
+					r12 >>= 16;
+					if (r8 > 255) r8 = 255;
+					r12 |= r3 << 16;
+
+					tmpl = (ulong)(((long)(int)r8) * ((long)(int)r12));
+					r3 = (uint)(tmpl & 0xFFFFFFFF);
+					r12 = (uint)((tmpl >> 32) & 0xFFFFFFFF);
+
+					r12 = r6 << 29;
+					r6++;
+					r4 += r12 >> 26;
+					Info.QuantizationTables[r7][r4] = r3;
+					if (r6 >= 0x40) break;
+				}
+				r7++;
+				if (r7 >= 2) break;
+			}
+		}
+
+		private static Bitmap ToBitmap(FMVInfo Info, byte[] FrameBlockData, byte[] FrameData)
+		{
+			Info.BitReg = 0;
+			Info.BitRegNrBits = 0;
+			Info.PhaseInfos[0].Field10 = 0;
+			Info.PhaseInfos[1].Field10 = 0;
+			Info.PhaseInfos[2].Field10 = 0;
+
+			int offset = 0;
+			for (int y = 0; y < Info.NrTilesY; y++)
+			{
+				for (int x = 0; x < Info.NrTilesX; x++)
+				{
+					int type = FrameBlockData[y * Info.NrTilesX + x];
+					switch (type)
+					{
+						case 0:
+							{
+							}
+							break;
+						case 1:
+							{
+								if (Info.BitRegNrBits < 5) FillBits(FrameData, ref Info.BitReg, ref Info.BitRegNrBits, ref offset);
+								Info.BitRegNrBits -= 5;
+								int a = (int)(Info.BitReg >> Info.BitRegNrBits) & 0x1F;
+								if (a > 15) a -= 32;
+								if (Info.BitRegNrBits < 5) FillBits(FrameData, ref Info.BitReg, ref Info.BitRegNrBits, ref offset);
+								Info.BitRegNrBits -= 5;
+								int b = (int)(Info.BitReg >> Info.BitRegNrBits) & 0x1F;
+								if (b > 15) b -= 32;
+								for (int _y = 0; _y < 16; _y++)
+								{
+									for (int _x = 0; _x < 16; _x++)
+									{
+										Info.PhaseInfos[0].PhaseData[((y * 16) + _y) * Info.PhaseInfos[0].PhaseDataWidth + ((x * 16) + _x)] = Info.PhaseInfos[0].PhaseDataOld[(((y * 16) + _y) - b) * Info.PhaseInfos[0].PhaseDataWidth + ((x * 16) + _x) - a];
+									}
+								}
+								for (int _y = 0; _y < 8; _y++)
+								{
+									for (int _x = 0; _x < 8; _x++)
+									{
+										Info.PhaseInfos[1].PhaseData[((y * 8) + _y) * Info.PhaseInfos[1].PhaseDataWidth + ((x * 8) + _x)] = Info.PhaseInfos[1].PhaseDataOld[(((y * 8) + _y) - b / 2) * Info.PhaseInfos[1].PhaseDataWidth + ((x * 8) + _x) - a / 2];
+									}
+								}
+								for (int _y = 0; _y < 8; _y++)
+								{
+									for (int _x = 0; _x < 8; _x++)
+									{
+										Info.PhaseInfos[2].PhaseData[((y * 8) + _y) * Info.PhaseInfos[2].PhaseDataWidth + ((x * 8) + _x)] = Info.PhaseInfos[2].PhaseDataOld[(((y * 8) + _y) - b / 2) * Info.PhaseInfos[2].PhaseDataWidth + ((x * 8) + _x) - a / 2];
+									}
+								}
+							}
+							break;
+						case 2:
+							{
+								if (Info.BitRegNrBits < 8) FillBits(FrameData, ref Info.BitReg, ref Info.BitRegNrBits, ref offset);
+								Info.BitRegNrBits -= 8;
+								int a = (int)(Info.BitReg >> Info.BitRegNrBits) & 0xFF;
+								if (Info.BitRegNrBits < 8) FillBits(FrameData, ref Info.BitReg, ref Info.BitRegNrBits, ref offset);
+								Info.BitRegNrBits -= 8;
+								int b = (int)(Info.BitReg >> Info.BitRegNrBits) & 0xFF;
+								if (Info.BitRegNrBits < 8) FillBits(FrameData, ref Info.BitReg, ref Info.BitRegNrBits, ref offset);
+								Info.BitRegNrBits -= 8;
+								int c = (int)(Info.BitReg >> Info.BitRegNrBits) & 0xFF;
+								for (int _y = 0; _y < 16; _y++)
+								{
+									for (int _x = 0; _x < 16; _x++)
+									{
+										Info.PhaseInfos[0].PhaseData[((y * 16) + _y) * Info.PhaseInfos[0].PhaseDataWidth + ((x * 16) + _x)] = (byte)a;
+									}
+								}
+								for (int _y = 0; _y < 8; _y++)
+								{
+									for (int _x = 0; _x < 8; _x++)
+									{
+										Info.PhaseInfos[1].PhaseData[((y * 8) + _y) * Info.PhaseInfos[1].PhaseDataWidth + ((x * 8) + _x)] = (byte)b;
+									}
+								}
+								for (int _y = 0; _y < 8; _y++)
+								{
+									for (int _x = 0; _x < 8; _x++)
+									{
+										Info.PhaseInfos[2].PhaseData[((y * 8) + _y) * Info.PhaseInfos[2].PhaseDataWidth + ((x * 8) + _x)] = (byte)c;
+									}
+								}
+							}
+							break;
+						case 255:
+							{
+								for (int i = 0; i < Info.NrPhases; i++)
+								{
+									for (int j = 0; j < Info.PhaseInfos[i].NrBlocksX * Info.PhaseInfos[i].NrBlocksY; j++)
+									{
+										ushort[] r7 = new ushort[0x40];
+										if (Info.BitRegNrBits < 16) FillBits(FrameData, ref Info.BitReg, ref Info.BitRegNrBits, ref offset);
+										int a = (int)(Info.BitReg >> (Info.BitRegNrBits - 10)) & 0x3FF;
+										int q = Info.field_0[Info.PhaseInfos[i].Table1Idx][a];
+										int r10;
+										if (q >= 255)
+										{
+											uint v12;
+											if (Info.BitRegNrBits >= 16) v12 = Info.BitReg >> (Info.BitRegNrBits - 16);
+											else v12 = Info.BitReg << (16 - Info.BitRegNrBits);
+											v12 &= 0xFFFF;
+											int qq = 0xB;
+											while (true)
+											{
+												if (v12 >= Info.field_804[Info.PhaseInfos[i].Table1Idx][qq]) qq++;
+												else break;
+											}
+											int v16 = (int)(((1 << qq) - 1) & (Info.BitReg >> (Info.BitRegNrBits - qq))) + (int)Info.field_84C[Info.PhaseInfos[i].Table1Idx][qq];//*(v15 + 531);
+											Info.BitRegNrBits -= qq;
+											r10 = Info.field_600[Info.PhaseInfos[i].Table1Idx][v16];
+										}
+										else
+										{
+											int q2 = Info.field_700[Info.PhaseInfos[i].Table1Idx][q];
+											Info.BitRegNrBits -= q2;
+											r10 = Info.field_600[Info.PhaseInfos[i].Table1Idx][q];
+										}
+										uint _r5 = 0;
+										sub_213474C(ref r7, 0, 0x80);
+										if (r10 != 0)
+										{
+											if (Info.BitRegNrBits < r10) FillBits(FrameData, ref Info.BitReg, ref Info.BitRegNrBits, ref offset);
+											Info.BitRegNrBits -= r10;
+											int mask = (1 << r10) - 1;
+											_r5 = (uint)((int)(Info.BitReg >> Info.BitRegNrBits) & mask);
+											if (_r5 < (1 << (r10 - 1)))
+											{
+												uint _r0 = 0xFFFFFFFF;
+												_r0 = _r5 + (_r0 << r10);
+												_r5 = (uint)(((int)_r0) + 1);
+											}
+										}
+										Info.PhaseInfos[i].Field10 += (int)_r5;
+										r7[0] = (ushort)Info.PhaseInfos[i].Field10;
+
+										int counter = 1;
+										while (true)
+										{
+											if (Info.BitRegNrBits < 16) FillBits(FrameData, ref Info.BitReg, ref Info.BitRegNrBits, ref offset);
+											int c = (int)(Info.BitReg >> (Info.BitRegNrBits - 10)) & 0x3FF;
+											int qc = Info.field_1200[Info.PhaseInfos[i].Table2Idx][c];
+											int r1;
+											if (qc >= 255)
+											{
+												uint r0;
+												if (Info.BitRegNrBits < 16)
+												{
+													r0 = 16 - (uint)Info.BitRegNrBits;
+													r0 = (uint)(Info.BitReg << (int)r0);
+												}
+												else
+												{
+													r0 = (uint)Info.BitRegNrBits - 16;
+													r0 = (uint)(Info.BitReg >> (int)r0);
+												}
+												r0 <<= 16;
+												uint r9 = r0 >> 16;
+												int r3 = 0xB;
+												while (true)
+												{
+													if (r9 >= Info.field_1A04[Info.PhaseInfos[i].Table2Idx][r3]) r3++;
+													else break;
+												}
+												uint r5 = (uint)1 << r3;
+												r9 = r5 - 1;
+												r5 = (uint)(Info.BitRegNrBits - r3);
+												r5 = r9 & (Info.BitReg >> (int)r5);
+												int r2 = (int)Info.field_1A4C[Info.PhaseInfos[i].Table2Idx][r3];
+												Info.BitRegNrBits -= r3;
+												r1 = Info.field_1800[Info.PhaseInfos[i].Table2Idx][r5 + r2];
+											}
+											else
+											{
+												int q2c = Info.field_1900[Info.PhaseInfos[i].Table2Idx][qc];
+												Info.BitRegNrBits -= q2c;
+												r1 = Info.field_1800[Info.PhaseInfos[i].Table2Idx][qc];
+											}
+											r10 = r1 & 0xF;
+											if (r10 != 0)
+											{
+												counter += r1 >> 4;
+												if (Info.BitRegNrBits < r10) FillBits(FrameData, ref Info.BitReg, ref Info.BitRegNrBits, ref offset);
+												Info.BitRegNrBits -= r10;
+												int mask = (1 << r10) - 1;
+												uint d = (uint)((Info.BitReg >> Info.BitRegNrBits) & mask);
+												uint r0;
+												if (d < (1 << (r10 - 1)))
+												{
+													r0 = 0xFFFFFFFF;
+													r0 = (uint)(d + (r0 << r10));
+													d = r0 + 1;
+												}
+												r0 = ZigZagTable[counter];
+												counter++;
+												r7[r0] = (ushort)d;
+											}
+											else if (r1 != 0xF0) break;
+											else counter += 16;
+											if (counter >= 0x40) goto con;
+											continue;
+										}
+									con:
+										byte[] data = sub_20A66B0(r7, Info.QuantizationTables[Info.PhaseInfos[i].QTIdx]);
+										if (i == 0)
+										{
+											for (int qq = 0; qq < 64; qq++)
+											{
+												int _x = (qq % 8) + x * 16 + (j % 2 * 8);
+												int _y = (qq / 8) + y * 16 + (j / 2 * 8);
+												Info.PhaseInfos[i].PhaseData[_y * Info.PhaseInfos[i].PhaseDataWidth + _x] = data[qq];
+											}
+										}
+										else if (i == 1)
+										{
+											for (int qq = 0; qq < 64; qq++)
+											{
+												int _x = (qq % 8) + x * 8;
+												int _y = (qq / 8) + y * 8;
+												Info.PhaseInfos[i].PhaseData[_y * Info.PhaseInfos[i].PhaseDataWidth + _x] = data[qq];
+											}
+										}
+										else
+										{
+											for (int qq = 0; qq < 64; qq++)
+											{
+												int _x = (qq % 8) + x * 8;
+												int _y = (qq / 8) + y * 8;
+												Info.PhaseInfos[i].PhaseData[_y * Info.PhaseInfos[i].PhaseDataWidth + _x] = data[qq];
+											}
+										}
+										continue;
+									}
+								}
+							}
+							break;
+					}
+				}
+			}
+			Bitmap bb4 = new Bitmap(Info.Width, Info.Height);
+			for (int y = 0; y < Info.Height; y++)
+			{
+				for (int x = 0; x < Info.Width; x++)
+				{
+					float Y = Info.PhaseInfos[0].PhaseData[y * Info.PhaseInfos[0].PhaseDataWidth + x] / 256f;
+					float U = Info.PhaseInfos[1].PhaseData[y / 2 * Info.PhaseInfos[1].PhaseDataWidth + x / 2] / 256f - 0.5f;
+					float V = Info.PhaseInfos[2].PhaseData[y / 2 * Info.PhaseInfos[2].PhaseDataWidth + x / 2] / 256f - 0.5f;
+					float R = Y + V * 1.13983f;
+					float G = Y - U * 0.39465f - V * 0.58060f;
+					float B = Y + U * 2.03211f;
+					if (R < 0) R = 0;
+					if (R > 1) R = 1;
+					if (G < 0) G = 0;
+					if (G > 1) G = 1;
+					if (B < 0) B = 0;
+					if (B > 1) B = 1;
+					bb4.SetPixel(x, y, Color.FromArgb((int)(R * 255), (int)(G * 255), (int)(B * 255)));
+				}
+			}
+			Array.Copy(Info.PhaseInfos[0].PhaseData, Info.PhaseInfos[0].PhaseDataOld, Info.PhaseInfos[0].PhaseData.Length);
+			Array.Copy(Info.PhaseInfos[1].PhaseData, Info.PhaseInfos[1].PhaseDataOld, Info.PhaseInfos[1].PhaseData.Length);
+			Array.Copy(Info.PhaseInfos[2].PhaseData, Info.PhaseInfos[2].PhaseDataOld, Info.PhaseInfos[2].PhaseData.Length);
+			return bb4;
+		}
+
+		private static void FillBits(byte[] FrameData, ref uint bitreg, ref int nrbits, ref int offset)
+		{
+			while (nrbits <= 24)
+			{
+				byte a;
+				if (offset + 1 < FrameData.Length) a = FrameData[offset++];
+				else a = 0;
+				bitreg = bitreg << 8 | a;
+				nrbits += 8;
+			}
+		}
+
+		private static void sub_213474C(ref ushort[] r0, uint r1, uint r2)
+		{
+			byte[] data = new byte[r0.Length * 2];
+			for (int i = 0; i < r0.Length; i++)
+			{
+				data[i * 2] = (byte)(r0[i] & 0xFF);
+				data[i * 2 + 1] = (byte)((r0[i] >> 8) & 0xFF);
+			}
+			int Offset = 0;
+
+			uint r3 = r1 & 0xFF;
+			if (r2 >= 0x20)
+			{
+				if (r3 != 0)
+				{
+					r1 = r3 << 16;
+					r1 |= r3 << 24;
+					r1 |= r3 << 8;
+					r3 |= r1;
+				}
+				r1 = r2 >> 5;
+				while (r1 != 0)
+				{
+					//0
+					data[Offset++] = (byte)(r3 & 0xFF);
+					data[Offset++] = (byte)((r3 >> 8) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 16) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 24) & 0xFF);
+					//4
+					data[Offset++] = (byte)(r3 & 0xFF);
+					data[Offset++] = (byte)((r3 >> 8) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 16) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 24) & 0xFF);
+					//8
+					data[Offset++] = (byte)(r3 & 0xFF);
+					data[Offset++] = (byte)((r3 >> 8) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 16) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 24) & 0xFF);
+					//12
+					data[Offset++] = (byte)(r3 & 0xFF);
+					data[Offset++] = (byte)((r3 >> 8) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 16) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 24) & 0xFF);
+					//16
+					data[Offset++] = (byte)(r3 & 0xFF);
+					data[Offset++] = (byte)((r3 >> 8) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 16) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 24) & 0xFF);
+					//20
+					data[Offset++] = (byte)(r3 & 0xFF);
+					data[Offset++] = (byte)((r3 >> 8) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 16) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 24) & 0xFF);
+					//24
+					data[Offset++] = (byte)(r3 & 0xFF);
+					data[Offset++] = (byte)((r3 >> 8) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 16) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 24) & 0xFF);
+					//28
+					data[Offset++] = (byte)(r3 & 0xFF);
+					data[Offset++] = (byte)((r3 >> 8) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 16) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 24) & 0xFF);
+					r1--;
+				}
+				r1 = r2 & 0x1F;
+				r1 >>= 2;
+				while (r1 != 0)
+				{
+					data[Offset++] = (byte)(r3 & 0xFF);
+					data[Offset++] = (byte)((r3 >> 8) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 16) & 0xFF);
+					data[Offset++] = (byte)((r3 >> 24) & 0xFF);
+					r1--;
+				}
+				r2 &= 3;
+			}
+			if (r2 == 0) goto ret;
+			r1 = r3 & 0xFF;
+			while (true)
+			{
+				data[Offset++] = (byte)r1;
+				r2--;
+				if (r2 == 0) break;
+			}
+		ret:
+			for (int i = 0; i < r0.Length; i++)
+			{
+				r0[i] = (ushort)(data[i * 2] | (data[i * 2 + 1] << 8));
+			}
+		}
+
+		private static byte[] sub_20A66B0(ushort[] indata, uint[] QuantizationTable)
+		{
+			byte[] data = new byte[indata.Length * 2];
+			for (int i = 0; i < indata.Length; i++)
+			{
+				data[i * 2] = (byte)(indata[i] & 0xFF);
+				data[i * 2 + 1] = (byte)((indata[i] >> 8) & 0xFF);
+			}
+			int DOffset = 0;
+			int QTOffset = 0;
+			int R0Offset = 0;
+			int R5Offset = 0;
+
+			int Counter = 0;
+			byte[] r0data = new byte[64];
+			uint[] r5data = new uint[64];
+
+			uint r2;
+			uint r3;
+			uint r4;
+			uint r5;
+			uint r6;
+			uint r7;
+			uint r8;
+			uint r9;
+			uint r10;
+			uint r11;
+			uint r12;
+			uint lr;
+
+			uint SP_660_var_644;
+			uint SP_660_var_648;
+			uint SP_660_var_64C;
+			uint SP_660_var_650;
+			uint SP_660_var_654;
+			uint SP_660_var_658;
+
+			while (true)
+			{
+				bool tmp;
+				r8 = (uint)(int)IOUtil.ReadS16LE(data, DOffset + 2);
+				if (tmp = r8 == 0)
+				{
+					r4 = IOUtil.ReadU32LE(data, DOffset + 4);
+					if (tmp = r4 == 0)
+					{
+						r4 = IOUtil.ReadU32LE(data, DOffset + 8);
+						if (tmp = r4 == 0)
+						{
+							r4 = IOUtil.ReadU32LE(data, DOffset + 12);
+							tmp = r4 == 0;
+						}
+					}
+				}
+				if (tmp)
+				{
+					r6 = (uint)(int)IOUtil.ReadS16LE(data, DOffset + 0);
+					r4 = QuantizationTable[QTOffset + 0];
+					r4 = r6 * r4;
+					r5data[R5Offset + 0] = r4;
+					r5data[R5Offset + 8] = r4;
+					r5data[R5Offset + 16] = r4;
+					r5data[R5Offset + 24] = r4;
+					r5data[R5Offset + 32] = r4;
+					r5data[R5Offset + 40] = r4;
+					r5data[R5Offset + 48] = r4;
+					r5data[R5Offset + 56] = r4;
+					goto loc_20A687C;
+				}
+				r7 = QuantizationTable[QTOffset + 1];
+				r6 = (uint)(int)IOUtil.ReadS16LE(data, DOffset + 6);
+				lr = r8 * r7;
+				r4 = QuantizationTable[QTOffset + 3];
+				r8 = (uint)(int)IOUtil.ReadS16LE(data, DOffset + 10);
+				r7 = r6 * r4;
+				r6 = QuantizationTable[QTOffset + 5];
+				r4 = (uint)(int)IOUtil.ReadS16LE(data, DOffset + 0);
+				r9 = QuantizationTable[QTOffset + 0];
+				r6 = r8 * r6;
+				r12 = r4 * r9;
+				r8 = (uint)(int)IOUtil.ReadS16LE(data, DOffset + 4);
+				r4 = QuantizationTable[QTOffset + 2];
+				r10 = (uint)(int)IOUtil.ReadS16LE(data, DOffset + 8);
+				r4 = r8 * r4;
+				r9 = QuantizationTable[QTOffset + 4];
+				r8 = (uint)(int)IOUtil.ReadS16LE(data, DOffset + 12);
+				r11 = QuantizationTable[QTOffset + 6];
+				r9 = r10 * r9;
+				r11 = r8 * r11;
+				r10 = r12 + r9;
+				r9 = r12 - r9;
+				r8 = r4 + r11;
+				r12 = r4 - r11;
+				r4 = 0x16A0A;
+
+				ulong tmpl = (ulong)(((long)(int)r12) * ((long)(int)r4));
+				r11 = (uint)(tmpl & 0xFFFFFFFF);
+				r4 = (uint)((tmpl >> 32) & 0xFFFFFFFF);
+
+				r11 >>= 16;
+				r11 |= r4 << 16;
+				r4 = r11 - r8;
+				r11 = r10 + r8;
+				r8 = r10 - r8;
+				r10 = r9 + r4;
+				r4 = r9 - r4;
+				SP_660_var_658 = r4;
+				SP_660_var_648 = r10;
+				r10 = r6 + r7;
+				r9 = (uint)(int)IOUtil.ReadS16LE(data, DOffset + 14);
+				r4 = QuantizationTable[QTOffset + 7];
+				r6 = r6 - r7;
+				r4 = r9 * r4;
+				r7 = lr + r4;
+				SP_660_var_64C = r11;
+				r9 = lr - r4;
+				r4 = r7 + r10;
+				r11 = r7 - r10;
+				r7 = 0x16A0A;
+
+				tmpl = (ulong)(((long)(int)r11) * ((long)(int)r7));
+				r10 = (uint)(tmpl & 0xFFFFFFFF);
+				r7 = (uint)((tmpl >> 32) & 0xFFFFFFFF);
+
+				r11 = r10 >> 16;
+				r11 |= r7 << 16;
+				r10 = 0x1D907;
+				r7 = r6 + r9;
+
+				tmpl = (ulong)(((long)(int)r7) * ((long)(int)r10));
+				r12 = (uint)(tmpl & 0xFFFFFFFF);
+				r10 = (uint)((tmpl >> 32) & 0xFFFFFFFF);
+
+				r7 = r12 >> 16;
+				SP_660_var_654 = r10;
+				r7 |= r10 << 16;
+				r10 = 0x11518;
+
+				tmpl = (ulong)(((long)(int)r10) * ((long)(int)r9));
+				r12 = (uint)(tmpl & 0xFFFFFFFF);
+				r9 = (uint)((tmpl >> 32) & 0xFFFFFFFF);
+
+				r10 = r12 >> 16;
+				r10 |= r9 << 16;
+				r9 = 0xFFFD630B;
+				r10 = r10 - r7;
+
+				tmpl = (ulong)(((long)(int)r9) * ((long)(int)r6));
+				r12 = (uint)(tmpl & 0xFFFFFFFF);
+				r6 = (uint)((tmpl >> 32) & 0xFFFFFFFF);
+
+				r9 = r12 >> 16;
+				r9 |= r6 << 16;
+				r6 = r9 + r7;
+				r9 = r6 - r4;
+				r7 = r11 - r9;
+				r6 = r10 + r7;
+				r10 = SP_660_var_64C;
+				r11 = r10 + r4;
+				r4 = r10 - r4;
+				r5data[R5Offset + 0] = r11;
+				r5data[R5Offset + 56] = r4;
+				r4 = SP_660_var_648;
+				r10 = r4 + r9;
+				r4 = r4 - r9;
+				r5data[R5Offset + 8] = r10;
+				r5data[R5Offset + 48] = r4;
+				r4 = SP_660_var_658;
+				r9 = r4 + r7;
+				r4 = r4 - r7;
+				r5data[R5Offset + 16] = r9;
+				r5data[R5Offset + 40] = r4;
+				r7 = r8 + r6;
+				r4 = r8 - r6;
+				r5data[R5Offset + 32] = r7;
+				r5data[R5Offset + 24] = r4;
+			loc_20A687C:
+				DOffset += 16;
+				Counter++;
+				QTOffset += 8;
+				R5Offset++;
+				if (Counter >= 8) break;
+			}
+			Counter = 0;
+			R5Offset = 0;
+			r4 = 0xFF;
+			while (true)
+			{
+				r5 = r5data[R5Offset + 4];
+				r2 = r5data[R5Offset + 0];
+				r8 = r5data[R5Offset + 6];
+				r7 = r5data[R5Offset + 2];
+				r3 = r2 + r5;
+				r6 = r2 - r5;
+				r2 = r7 + r8;
+				r9 = r7 - r8;
+				r7 = 0x16A0A;
+				r12 = r3 + r2;
+
+				ulong tmpl = (ulong)(((long)(int)r9) * ((long)(int)r7));
+				r8 = (uint)(tmpl & 0xFFFFFFFF);
+				r7 = (uint)((tmpl >> 32) & 0xFFFFFFFF);
+
+				r8 >>= 16;
+				r8 |= r7 << 16;
+				r7 = r8 - r2;
+				r3 = r3 - r2;
+				r5 = r5data[R5Offset + 3];
+				r8 = r5data[R5Offset + 5];
+				r2 = r6 + r7;
+				r11 = r6 - r7;
+				r6 = r8 + r5;
+				r9 = r8 - r5;
+				r5 = 0xFFFD630B;
+				SP_660_var_644 = r6;
+
+				tmpl = (ulong)(((long)(int)r5) * ((long)(int)r9));
+				r10 = (uint)(tmpl & 0xFFFFFFFF);
+				r8 = (uint)((tmpl >> 32) & 0xFFFFFFFF);
+
+				r5 = r10 >> 16;
+				r7 = r5data[R5Offset + 7];
+				r6 = r5data[R5Offset + 1];
+				r5 |= r8 << 16;
+				r8 = r6 + r7;
+				r7 = r6 - r7;
+				r6 = 0x1D907;
+				r10 = r9 + r7;
+
+				tmpl = (ulong)(((long)(int)r10) * ((long)(int)r6));
+				r9 = (uint)(tmpl & 0xFFFFFFFF);
+				r6 = (uint)((tmpl >> 32) & 0xFFFFFFFF);
+
+				SP_660_var_650 = r6;
+				r6 = r9 >> 16;
+				r9 = SP_660_var_650;
+				R5Offset += 8;
+				r6 |= r9 << 16;
+				r9 = 0x11518;
+				r5 = r5 + r6;
+
+				tmpl = (ulong)(((long)(int)r9) * ((long)(int)r7));
+				r10 = (uint)(tmpl & 0xFFFFFFFF);
+				r7 = (uint)((tmpl >> 32) & 0xFFFFFFFF);
+
+				r9 = r10 >> 16;
+				r9 |= r7 << 16;
+				r9 = r9 - r6;
+				r6 = SP_660_var_644;
+				r7 = r8 + r6;
+				r6 = r8 - r6;
+				r8 = 0x16A0A;
+				r5 = r5 - r7;
+
+				tmpl = (ulong)(((long)(int)r6) * ((long)(int)r8));
+				r10 = (uint)(tmpl & 0xFFFFFFFF);
+				r8 = (uint)((tmpl >> 32) & 0xFFFFFFFF);
+
+				r6 = r10 >> 16;
+				r6 |= r8 << 16;
+				r8 = r6 - r5;
+				r6 = r9 + r8;
+				r9 = r12 + r7;
+
+				r9 = (uint)((int)r9 >> 19);
+				r9 += 0x80;
+				r7 = r12 - r7;
+				if (((int)r9) < 0) r9 = 0;
+				if (r9 > 255) r9 = r4;
+
+				r7 = (uint)((int)r7 >> 19);
+				r7 += 0x80;
+				if (((int)r7) < 0) r7 = 0;
+				r0data[R0Offset + 0] = (byte)r9;
+				if (r7 > 255) r7 = r4;
+
+				r0data[R0Offset + 7] = (byte)r7;
+				r7 = r2 + r5;
+
+				r7 = (uint)((int)r7 >> 19);
+				r7 += 0x80;
+				r2 = r2 - r5;
+				if (((int)r7) < 0) r7 = 0;
+				if (r7 > 255) r7 = r4;
+
+				r2 = (uint)((int)r2 >> 19);
+				r2 += 0x80;
+				if (((int)r2) < 0) r2 = 0;
+				r0data[R0Offset + 1] = (byte)r7;
+				if (r2 > 255) r2 = r4;
+
+				r0data[R0Offset + 6] = (byte)r2;
+				r2 = r11 + r8;
+
+				r2 = (uint)((int)r2 >> 19);
+				r5 = r2 + 0x80;
+				r2 = r11 - r8;
+				if (((int)r5) < 0) r5 = 0;
+				if (r5 > 255) r5 = r4;
+
+				r2 = (uint)((int)r2 >> 19);
+				r2 += 0x80;
+				if (((int)r2) < 0) r2 = 0;
+				r0data[R0Offset + 2] = (byte)r5;
+				if (r2 > 255) r2 = r4;
+
+				r0data[R0Offset + 5] = (byte)r2;
+				r2 = r3 + r6;
+
+				r2 = (uint)((int)r2 >> 19);
+				r5 = r2 + 0x80;
+				r2 = r3 - r6;
+				if (((int)r5) < 0) r5 = 0;
+				if (r5 > 255) r5 = r4;
+
+				r2 = (uint)((int)r2 >> 19);
+				r2 += 0x80;
+				if (((int)r2) < 0) r2 = 0;
+				r0data[R0Offset + 4] = (byte)r5;
+				if (r2 > 255) r2 = r4;
+
+				r0data[R0Offset + 3] = (byte)r2;
+				R0Offset += 8;
+				Counter++;
+				if (Counter >= 8) break;
+			}
+			return r0data;
+		}
+
+		private static byte[] DecompressRLE(byte[] Data, int DataOffset, int Length)
+		{
+			List<byte> OutputData = new List<byte>();
+			int Offset = DataOffset;
+			int R5 = Data[Offset++];
+			int R12;
+			int LR;
+			while (true)
+			{
+				R12 = Data[Offset++];
+				if (R12 == R5)
+				{
+					LR = Data[Offset++];
+					if (LR <= 2)
+					{
+						R12 = 0;
+						while (true)
+						{
+							R12++;
+							OutputData.Add((byte)R5);
+							if (R12 > LR) break;
+						}
+						goto loc_20A5AA0;
+					}
+					if ((LR & 0x80) != 0)
+					{
+						R12 = Data[Offset++];
+						LR <<= 25;
+						LR = R12 + (LR >> 17);
+					}
+					R12 = Data[Offset++];
+					int R8 = 0;
+					while (true)
+					{
+						R8++;
+						OutputData.Add((byte)R12);
+						if (R8 > LR) break;
+					}
+					goto loc_20A5AA0;
+				}
+				OutputData.Add((byte)R12);
+			loc_20A5AA0:
+				if (Offset >= (Length + DataOffset)) break;
+			}
+			return OutputData.ToArray();
+		}
+
+		private class FMVInfo
+		{
+			public FMVInfo(FMV f, EndianBinaryReader er)
+			{
+				this.er = er;
+				Width = f.Header.Width;
+				Height = f.Header.Height;
+				NrTilesX = Width / 16;
+				NrTilesY = Height / 16;
+				PhaseInfos[0] = new PhaseInfo(this, 2, 2, 0, 0, 0);
+				PhaseInfos[1] = new PhaseInfo(this, 1, 1, 1, 1, 1);
+				PhaseInfos[2] = new PhaseInfo(this, 1, 1, 1, 1, 1);
+			}
+			public EndianBinaryReader er;
+
+			public byte[][] field_0 = new byte[2][];
+			public ushort[][] field_400 = new ushort[2][];
+			public byte[][] field_600 = new byte[2][];
+			public byte[][] field_700 = new byte[2][];
+			public uint[][] field_804 = new uint[2][];
+			public uint[][] field_84C = new uint[2][];
+
+			public byte[][] field_1200 = new byte[2][];
+			public ushort[][] field_1600 = new ushort[2][];
+			public byte[][] field_1800 = new byte[2][];
+			public byte[][] field_1900 = new byte[2][];
+			public uint[][] field_1A04 = new uint[2][];
+			public uint[][] field_1A4C = new uint[2][];
+
+			public bool FirstKeyFrame = true;
+
+			public int Width;
+			public int Height;
+			public int NrPhases = 3;
+			public int Quality = 0;
+			public uint[][] QuantizationTables = new uint[2][];
+			public int NrTilesX;
+			public int NrTilesY;
+			public uint BitReg = 0;
+			public int BitRegNrBits = 0;
+			public PhaseInfo[] PhaseInfos = new PhaseInfo[3];
+
+			public Bitmap LastFrame;
+
+			public class PhaseInfo
+			{
+				public PhaseInfo(FMVInfo Info, int NrBlocksX, int NrBlocksY, int QTIdx, int Table1Idx, int Table2Idx)
+				{
+					this.NrBlocksX = NrBlocksX;
+					this.NrBlocksY = NrBlocksY;
+					this.QTIdx = QTIdx;
+					this.Table1Idx = Table1Idx;
+					this.Table2Idx = Table2Idx;
+					Field10 = 0;
+					PhaseDataWidth = 8 * Info.NrTilesX * NrBlocksX;
+					PhaseDataHeight = 8 * Info.NrTilesY * NrBlocksY;
+					PhaseData = new byte[PhaseDataWidth * PhaseDataHeight];
+					PhaseDataOld = new byte[PhaseDataWidth * PhaseDataHeight];
+				}
+				public int NrBlocksX;
+				public int NrBlocksY;
+				public int QTIdx;
+				public int Table1Idx;
+				public int Table2Idx;
+				public int Field10;
+				public int PhaseDataWidth;
+				public int PhaseDataHeight;
+				public byte[] PhaseData;
+				public byte[] PhaseDataOld;
+			}
+
+		}
+
+		public class FMVIdentifier : FileFormatIdentifier
+		{
+			public override string GetCategory()
+			{
+				return Category_Videos;
+			}
+
+			public override string GetFileDescription()
+			{
+				return "Lego Pirates of the Carribean Cutscenes (FMV)";
+			}
+
+			public override string GetFileFilter()
+			{
+				return "Lego Pirates of the Carribean Cutscenes (*.fmv)|*.fmv";
+			}
+
+			public override Bitmap GetIcon()
+			{
+				return null;
+			}
+
+			public override FormatMatch IsFormat(EFEFile File)
+			{
+				if (File.Data.Length > 4 && File.Data[0] == 'F' && File.Data[1] == 'M' && File.Data[2] == 'V' && File.Data[3] == '!') return FormatMatch.Content;
+				return FormatMatch.No;
+			}
+		}
+	}
+}
diff --git a/LegoPirates/LegoPirates.csproj b/LegoPirates/LegoPirates.csproj
new file mode 100644
index 0000000..58104bd
--- /dev/null
+++ b/LegoPirates/LegoPirates.csproj
@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{E786AAC6-2D88-40E0-BFB6-45164A6183F9}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>LegoPirates</RootNamespace>
+    <AssemblyName>LegoPirates</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="NAudio">
+      <HintPath>..\Libraries\NAudio.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="FMV.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="UI\FMVViewer.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="UI\FMVViewer.designer.cs">
+      <DependentUpon>FMVViewer.cs</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\LibEveryFileExplorer\LibEveryFileExplorer.csproj">
+      <Project>{39DBD12F-F7E3-4E9A-97A2-0722A4BA2A26}</Project>
+      <Name>LibEveryFileExplorer</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\NDS\NDS.csproj">
+      <Project>{8BCF0C6C-FD8F-4446-BEA1-B8C1BE5C3389}</Project>
+      <Name>NDS</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="UI\FMVViewer.resx">
+      <DependentUpon>FMVViewer.cs</DependentUpon>
+    </EmbeddedResource>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PostBuildEvent>copy "$(TargetPath)" "$(SolutionDir)\EveryFileExplorer\bin\Debug\Plugins\$(TargetFileName)"</PostBuildEvent>
+  </PropertyGroup>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file
diff --git a/LegoPirates/Properties/AssemblyInfo.cs b/LegoPirates/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..4b59e9f
--- /dev/null
+++ b/LegoPirates/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Lego Pirates of the Carribean Plugin")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Every File Explorer")]
+[assembly: AssemblyCopyright("Copyright © Florian Nouwt 2014")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("58dd297a-249a-47c8-8e66-266a1615799f")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/LegoPirates/UI/FMVViewer.cs b/LegoPirates/UI/FMVViewer.cs
new file mode 100644
index 0000000..fc4631b
--- /dev/null
+++ b/LegoPirates/UI/FMVViewer.cs
@@ -0,0 +1,145 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+
+namespace LegoPirates.UI
+{
+	public partial class FMVViewer : Form
+	{
+		NAudio.Wave.BufferedWaveProvider AudioBuffer;
+		NAudio.Wave.WaveOut Player;
+		FMV Video;
+		public FMVViewer(FMV Video)
+		{
+			this.Video = Video;
+			InitializeComponent();
+		}
+
+		private void FMV_Load(object sender, EventArgs e)
+		{
+			/*double ticks = 10000000.0 / (Video.Header.FrameRate / 256.0);
+			float exp = (float)(ticks - Math.Floor(ticks));
+			if (exp != 0)
+			{
+				int i = 0;
+				float result;
+				do
+				{
+					i++;
+					result = exp * i;
+				}
+				while((float)(result - Math.Floor(result)) != 0);
+			}*/
+			//TODO: Calculate timing based on fps
+			if ((Video.Header.Flags & 4) == 4)
+			{
+				AudioBuffer = new NAudio.Wave.BufferedWaveProvider(new NAudio.Wave.WaveFormat((int)Video.Header.AudioRate, 16, 1));
+				AudioBuffer.DiscardOnBufferOverflow = true;
+				AudioBuffer.BufferLength = 8192 * 16;
+				Player = new NAudio.Wave.WaveOut();
+				Player.DesiredLatency = 150;
+				Player.Init(AudioBuffer);
+				Player.Play();
+			}
+			new System.Threading.Thread(new System.Threading.ThreadStart(delegate
+				{
+					int state = 0;
+					while (!stop)
+					{
+						if (Frames.Count != 0)
+						{
+							pictureBox1.Image = Frames.Dequeue();
+							switch (state) 
+							{
+								case 0: System.Threading.Thread.Sleep(TimeSpan.FromTicks(666666)); break;
+								case 1: System.Threading.Thread.Sleep(TimeSpan.FromTicks(666667)); break;
+								case 2: System.Threading.Thread.Sleep(TimeSpan.FromTicks(666667)); break;
+							}
+							state = (state + 1) % 3;
+						}
+					}
+					System.Threading.Thread.CurrentThread.Abort();
+				})).Start();
+			backgroundWorker1.RunWorkerAsync();
+		}
+
+		int aa = 0;
+		int bb = 0;
+		bool first = true;
+
+		Queue<Bitmap> Frames = new Queue<Bitmap>();
+
+		private void FMV_FormClosing(object sender, FormClosingEventArgs e)
+		{
+			if (!stop)
+			{
+				stop = true;
+				if ((Video.Header.Flags & 4) == 4)
+				{
+					Player.Stop();
+					Player.Dispose();
+					Player = null;
+					AudioBuffer = null;
+				}
+			}
+			Video.Close();
+		}
+		bool stop = false;
+		bool stopped = false;
+		private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
+		{
+			while (!stop)
+			{
+				if (Frames.Count < 8 || AudioBuffer.BufferedBytes < 8192 * 4)
+				{
+				retry:
+					byte[] audio;
+					Bitmap b = Video.GetNextFrame(out audio);
+					if (audio != null)
+					{
+						byte[] Return;
+						if (first) Return = new byte[(int)(audio.Length - 4) * 4];
+						else Return = new byte[audio.Length * 4];
+						unsafe
+						{
+							byte* buf = (byte*)Marshal.UnsafeAddrOfPinnedArrayElement(audio, 0);
+							byte* outbuffer = (byte*)Marshal.UnsafeAddrOfPinnedArrayElement(Return, 0);
+							int length = audio.Length;
+							if (first)
+							{
+								aa = ((short*)buf)[0];
+								bb = ((short*)buf)[1] & 0x7F;
+								((short*)outbuffer)[0] = (short)aa;
+								first = false;
+								buf += 4;
+								length -= 4;
+								outbuffer += 2;
+							}
+							NDS.SND.ADPCM.ConvertImaAdpcm(buf, length, outbuffer, ref aa, ref bb);
+						}
+						AudioBuffer.AddSamples(Return, 0, Return.Length);
+						goto retry;
+					}
+					if (b == null)
+					{
+						stop = true;
+						if ((Video.Header.Flags & 4) == 4)
+						{
+							Player.Stop();
+							Player.Dispose();
+							Player = null;
+							AudioBuffer = null;
+						}
+					}
+					else Frames.Enqueue(b);
+				}
+			}
+		}
+	}
+}
diff --git a/LegoPirates/UI/FMVViewer.designer.cs b/LegoPirates/UI/FMVViewer.designer.cs
new file mode 100644
index 0000000..0478f13
--- /dev/null
+++ b/LegoPirates/UI/FMVViewer.designer.cs
@@ -0,0 +1,70 @@
+namespace LegoPirates.UI
+{
+	partial class FMVViewer
+	{
+		/// <summary>
+		/// Required designer variable.
+		/// </summary>
+		private System.ComponentModel.IContainer components = null;
+
+		/// <summary>
+		/// Clean up any resources being used.
+		/// </summary>
+		/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing && (components != null))
+			{
+				components.Dispose();
+			}
+			base.Dispose(disposing);
+		}
+
+		#region Windows Form Designer generated code
+
+		/// <summary>
+		/// Required method for Designer support - do not modify
+		/// the contents of this method with the code editor.
+		/// </summary>
+		private void InitializeComponent()
+		{
+			this.pictureBox1 = new System.Windows.Forms.PictureBox();
+			this.backgroundWorker1 = new System.ComponentModel.BackgroundWorker();
+			((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit();
+			this.SuspendLayout();
+			// 
+			// pictureBox1
+			// 
+			this.pictureBox1.Dock = System.Windows.Forms.DockStyle.Fill;
+			this.pictureBox1.Location = new System.Drawing.Point(0, 0);
+			this.pictureBox1.Name = "pictureBox1";
+			this.pictureBox1.Size = new System.Drawing.Size(422, 326);
+			this.pictureBox1.SizeMode = System.Windows.Forms.PictureBoxSizeMode.CenterImage;
+			this.pictureBox1.TabIndex = 0;
+			this.pictureBox1.TabStop = false;
+			// 
+			// backgroundWorker1
+			// 
+			this.backgroundWorker1.DoWork += new System.ComponentModel.DoWorkEventHandler(this.backgroundWorker1_DoWork);
+			// 
+			// FMV
+			// 
+			this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+			this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+			this.ClientSize = new System.Drawing.Size(422, 326);
+			this.Controls.Add(this.pictureBox1);
+			this.Name = "FMV";
+			this.Text = "FMV";
+			this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.FMV_FormClosing);
+			this.Load += new System.EventHandler(this.FMV_Load);
+			((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit();
+			this.ResumeLayout(false);
+
+		}
+
+		#endregion
+
+		private System.Windows.Forms.PictureBox pictureBox1;
+		private System.ComponentModel.BackgroundWorker backgroundWorker1;
+	}
+}
\ No newline at end of file
diff --git a/LegoPirates/UI/FMVViewer.resx b/LegoPirates/UI/FMVViewer.resx
new file mode 100644
index 0000000..ba077aa
--- /dev/null
+++ b/LegoPirates/UI/FMVViewer.resx
@@ -0,0 +1,123 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <metadata name="backgroundWorker1.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>268, 17</value>
+  </metadata>
+</root>
\ No newline at end of file
diff --git a/LibEveryFileExplorer/Files/FileFormat.cs b/LibEveryFileExplorer/Files/FileFormat.cs
index d50c7df..fa07c62 100644
--- a/LibEveryFileExplorer/Files/FileFormat.cs
+++ b/LibEveryFileExplorer/Files/FileFormat.cs
@@ -30,6 +30,7 @@ namespace LibEveryFileExplorer.Files
 		protected const String Category_Shaders = "Shaders";
 		protected const String Category_Strings = "Strings";
 		protected const String Category_Textures = "Textures";
+		protected const String Category_Videos = "Videos";
 
 		public abstract String GetCategory();
 		public abstract String GetFileDescription();
diff --git a/Libraries/NAudio.dll b/Libraries/NAudio.dll
new file mode 100644
index 0000000..f1f70c7
Binary files /dev/null and b/Libraries/NAudio.dll differ
diff --git a/Libraries/Readme.txt b/Libraries/Readme.txt
deleted file mode 100644
index 2fdf58e..0000000
--- a/Libraries/Readme.txt
+++ /dev/null
@@ -1 +0,0 @@
-Put these 2 dll files in the plugins directory of efe!
\ No newline at end of file
diff --git a/NDS/NDS.csproj b/NDS/NDS.csproj
index 96c5755..6af8cb1 100644
--- a/NDS/NDS.csproj
+++ b/NDS/NDS.csproj
@@ -21,7 +21,7 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
-    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -70,6 +70,7 @@
       <DesignTime>True</DesignTime>
       <DependentUpon>Resource.resx</DependentUpon>
     </Compile>
+    <Compile Include="SND\ADPCM.cs" />
     <Compile Include="UI\MDL0MaterialEditor.cs">
       <SubType>UserControl</SubType>
     </Compile>
diff --git a/NDS/SND/ADPCM.cs b/NDS/SND/ADPCM.cs
new file mode 100644
index 0000000..fa2899d
--- /dev/null
+++ b/NDS/SND/ADPCM.cs
@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace NDS.SND
+{
+	//Tempoarly from mkdscm
+	//I need to rewrite this all
+	public class ADPCM
+	{
+		private static int[] indexTable = 
+		{ -1, -1, -1, -1, 2, 4, 6, 8,
+          -1, -1, -1, -1, 2, 4, 6, 8 };
+
+		private static int[] stepsizeTable = 
+		{ 7, 8, 9, 10, 11, 12, 13, 14,
+		  16, 17, 19, 21, 23, 25, 28,
+		  31, 34, 37, 41, 45, 50, 55,
+	      60, 66, 73, 80, 88, 97, 107,
+	      118, 130, 143, 157, 173, 190, 209,
+	      230, 253, 279, 307, 337, 371, 408,
+	      449, 494, 544, 598, 658, 724, 796,
+	      876, 963, 1060, 1166, 1282, 1411, 1552,
+	      1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327, 3660, 4026,
+	      4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630,
+	      9493, 10442, 11487, 12635, 13899, 15289, 16818,
+	      18500, 20350, 22385, 24623, 27086, 29794, 32767 };
+
+		public unsafe static void ConvertImaAdpcm(byte* buf, int length, byte* outbuffer)
+		{
+			int a = ((short*)buf)[0];
+			int b = ((short*)buf)[1] & 0x7F;
+			((short*)outbuffer)[0] = (short)a;
+			ConvertImaAdpcm(buf + 4, length - 4, outbuffer + 2, ref a, ref b);
+		}
+
+		public unsafe static void ConvertImaAdpcm(byte* buf, int length, byte* outbuffer, ref int decompSample, ref int stepIndex)
+		{
+			uint destOff = 0;
+			uint curOffset = 0;
+
+			byte compByte;
+			while (curOffset < length)
+			{
+				compByte = buf[curOffset++];
+				process_nibble(compByte, ref stepIndex, ref decompSample);
+				((short*)outbuffer)[destOff++] = (short)decompSample;
+				process_nibble((byte)((compByte & 0xF0) >> 4), ref stepIndex, ref decompSample);
+				((short*)outbuffer)[destOff++] = (short)decompSample;
+			}
+		}
+
+		private static int IMAMax(int samp) { return (samp > 0x7FFF) ? ((short)0x7FFF) : samp; }
+		private static int IMAMin(int samp) { return (samp < -0x7FFF) ? ((short)-0x7FFF) : samp; }
+		private static int IMAIndexMinMax(int index, int min, int max) { return (index > max) ? max : ((index < min) ? min : index); }
+
+		private static void process_nibble(byte data4bit, ref int Index, ref int Pcm16bit)
+		{
+			int Diff = stepsizeTable[Index] / 8;
+			if ((data4bit & 1) != 0) Diff = Diff + stepsizeTable[Index] / 4;
+			if ((data4bit & 2) != 0) Diff = Diff + stepsizeTable[Index] / 2;
+			if ((data4bit & 4) != 0) Diff = Diff + stepsizeTable[Index] / 1;
+
+			if ((data4bit & 8) == 0) Pcm16bit = IMAMax(Pcm16bit + Diff);
+			if ((data4bit & 8) == 8) Pcm16bit = IMAMin(Pcm16bit - Diff);
+			Index = IMAIndexMinMax(Index + indexTable[data4bit & 7], 0, 88);
+		}
+
+		private static void clamp_step_index(ref int stepIndex)
+		{
+			if (stepIndex < 0) stepIndex = 0;
+			if (stepIndex > 88) stepIndex = 88;
+		}
+
+		private static void clamp_sample(ref int decompSample)
+		{
+			if (decompSample < -32768) decompSample = -32768;
+			if (decompSample > 32767) decompSample = 32767;
+		}
+	}
+}